---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "gitea",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 17),
        },
        Raw {
         content: "gitea",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitea",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (8, 11),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (8, 15),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pg",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (9, 8),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (9, 15),
        },
        Raw {
         content: "postgresql",
         position: (9, 24),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useMysql",
        position: (10, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (10, 14),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (10, 18),
          },
          Raw {
           content: "type",
           position: (10, 27),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "mysql",
          position: (10, 36),
         },
        ],
       },
      ],
      position: (10, 32),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usePostgresql",
        position: (11, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (11, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (11, 23),
          },
          Raw {
           content: "type",
           position: (11, 32),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "postgres",
          position: (11, 41),
         },
        ],
       },
      ],
      position: (11, 37),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useSqlite",
        position: (12, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (12, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (12, 19),
          },
          Raw {
           content: "type",
           position: (12, 28),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "sqlite3",
          position: (12, 37),
         },
        ],
       },
      ],
      position: (12, 33),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (13, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (13, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "app.ini",
          position: (13, 32),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "APP_NAME = ",
          position: (14, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (14, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "appName",
              position: (14, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nRUN_USER = ",
          position: (14, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (15, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "user",
              position: (15, 22),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\nRUN_MODE = prod\n\n",
          position: (15, 27),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "generators",
             position: (18, 7),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "toINI",
               position: (18, 18),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Map {
             bindings: [],
             recursive: false,
             position: (18, 24),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (18, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "settings",
                position: (18, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n\n",
          position: (18, 40),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (20, 7),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (20, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "extraConfig",
                  position: (20, 27),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (20, 42),
              },
             ],
             position: (20, 39),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (20, 48),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "extraConfig",
                position: (20, 52),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (20, 64),
         },
        ],
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (25, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (26, 5),
           },
           Raw {
            content: "gitea",
            position: (26, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (27, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (27, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (28, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (28, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (29, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (29, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (29, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (30, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable Gitea Service.",
                    position: (30, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (27, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (33, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (33, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (34, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (34, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitea",
                     position: (34, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (35, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (35, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (35, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (36, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (36, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitea",
                      position: (36, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (37, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea derivation to use",
                    position: (37, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (33, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "useWizard",
               position: (40, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (40, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (41, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (41, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (42, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (42, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (42, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (43, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Do not generate a configuration and use gitea' installation wizard instead. The first registered user will be administrator.",
                    position: (43, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (40, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "stateDir",
               position: (46, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (46, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (47, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/gitea",
                    position: (47, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (48, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (48, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (48, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (49, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea data directory.",
                    position: (49, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (46, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "log",
               position: (52, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rootPath",
                  position: (53, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (53, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (54, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (54, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "stateDir",
                           position: (54, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/log",
                       position: (54, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (55, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (55, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\"",
                         position: (55, 45),
                        },
                        Raw {
                         content: "$",
                         position: (55, 46),
                        },
                        Raw {
                         content: "{config.",
                         position: (55, 49),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (55, 59),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "stateDir",
                             position: (55, 63),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "}/log\"",
                         position: (55, 72),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (56, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (56, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (56, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (57, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Root path for log files.",
                       position: (57, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (53, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "level",
                  position: (59, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (59, 17),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (60, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Info",
                       position: (60, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (61, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (61, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "enum",
                         position: (61, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "Trace",
                           position: (61, 32),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Debug",
                           position: (61, 40),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Info",
                           position: (61, 48),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Warn",
                           position: (61, 55),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Error",
                           position: (61, 62),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Critical",
                           position: (61, 70),
                          },
                         ],
                        },
                       ],
                       position: (61, 29),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (62, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "General log level.",
                       position: (62, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (59, 26),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (52, 13),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (66, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (66, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (67, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (67, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (67, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (68, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea",
                    position: (68, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (69, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User account under which gitea runs.",
                    position: (69, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (66, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database",
               position: (72, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (73, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (73, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (74, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (74, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "enum",
                         position: (74, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "sqlite3",
                           position: (74, 32),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mysql",
                           position: (74, 42),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "postgres",
                           position: (74, 50),
                          },
                         ],
                        },
                       ],
                       position: (74, 29),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (75, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mysql",
                       position: (75, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (76, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "sqlite3",
                       position: (76, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (77, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database engine to use.",
                       position: (77, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (73, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "host",
                  position: (80, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (80, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (81, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (81, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (81, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (82, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "127.0.0.1",
                       position: (82, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (83, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database host address.",
                       position: (83, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (80, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "port",
                  position: (86, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (86, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (87, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (87, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "port",
                        position: (87, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (88, 11),
                      },
                     ],
                    },
                    IfThenElse {
                     predicate: UnaryOperation {
                      operator: Not,
                      operand: Variable {
                       identifier: "usePostgresql",
                       position: (88, 26),
                      },
                      position: (88, 25),
                     },
                     then: Int {
                      value: 3306,
                      position: (88, 45),
                     },
                     else_: PropertyAccess {
                      expression: Variable {
                       identifier: "pg",
                       position: (88, 55),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "port",
                         position: (88, 58),
                        },
                       ],
                      },
                      default: None,
                     },
                     position: (88, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (89, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (89, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "if config.",
                         position: (90, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (90, 25),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "database",
                             position: (90, 29),
                            },
                            Raw {
                             content: "type",
                             position: (90, 38),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: " != \"postgresql\"\nthen 3306\nelse config.",
                         position: (90, 43),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "options",
                           position: (92, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "services",
                             position: (92, 35),
                            },
                            Raw {
                             content: "postgresql",
                             position: (92, 44),
                            },
                            Raw {
                             content: "port",
                             position: (92, 55),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (92, 60),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (94, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database host port.",
                       position: (94, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (86, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (97, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (97, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (98, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (98, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (98, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (99, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitea",
                       position: (99, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (100, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database name.",
                       position: (100, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (97, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "user",
                  position: (103, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (103, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (104, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (104, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (104, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (105, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitea",
                       position: (105, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (106, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Database user.",
                       position: (106, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (103, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "password",
                  position: (109, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (109, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (110, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (110, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (110, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (111, 11),
                      },
                     ],
                    },
                    String {
                     parts: [],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (112, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "The password corresponding to <option>database.user</option>.\nWarning: this is stored in cleartext in the Nix store!\nUse <option>database.passwordFile</option> instead.\n",
                       position: (113, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (109, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "passwordFile",
                  position: (119, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (119, 24),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (120, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (120, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (120, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (120, 31),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "path",
                          position: (120, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (121, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (121, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (122, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/keys/gitea-dbpassword",
                       position: (122, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (123, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "A file containing the password corresponding to\n<option>database.user</option>.\n",
                       position: (124, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (119, 33),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "socket",
                  position: (129, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (129, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (130, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (130, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (130, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (130, 31),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "path",
                          position: (130, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (131, 11),
                      },
                     ],
                    },
                    IfThenElse {
                     predicate: BinaryOperation {
                      operator: LogicalAnd,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (131, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (131, 29),
                          },
                          Raw {
                           content: "createDatabase",
                           position: (131, 38),
                          },
                         ],
                        },
                        default: None,
                       },
                       Variable {
                        identifier: "usePostgresql",
                        position: (131, 56),
                       },
                      ],
                      position: (131, 53),
                     },
                     then: String {
                      parts: [
                       Raw {
                        content: "/run/postgresql",
                        position: (131, 77),
                       },
                      ],
                     },
                     else_: IfThenElse {
                      predicate: BinaryOperation {
                       operator: LogicalAnd,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (131, 103),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "database",
                            position: (131, 107),
                           },
                           Raw {
                            content: "createDatabase",
                            position: (131, 116),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "useMysql",
                         position: (131, 134),
                        },
                       ],
                       position: (131, 131),
                      },
                      then: String {
                       parts: [
                        Raw {
                         content: "/run/mysqld/mysqld.sock",
                         position: (131, 150),
                        },
                       ],
                      },
                      else_: Variable {
                       identifier: "null",
                       position: (131, 180),
                      },
                      position: (131, 99),
                     },
                     position: (131, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (132, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (132, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "null",
                         position: (132, 44),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (133, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/mysqld/mysqld.sock",
                       position: (133, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (134, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to the unix socket file to use for authentication.",
                       position: (134, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (129, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (137, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (137, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (138, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (138, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (138, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (139, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (139, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "stateDir",
                           position: (139, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/data/gitea.db",
                       position: (139, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (140, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (140, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\"",
                         position: (140, 45),
                        },
                        Raw {
                         content: "$",
                         position: (140, 46),
                        },
                        Raw {
                         content: "{config.",
                         position: (140, 49),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (140, 59),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "stateDir",
                             position: (140, 63),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "}/data/gitea.db\"",
                         position: (140, 72),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (141, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to the sqlite3 database file.",
                       position: (141, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (137, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "createDatabase",
                  position: (144, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (144, 26),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (145, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (145, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (145, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (146, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (146, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (147, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to create a local database automatically.",
                       position: (147, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (144, 35),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (72, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dump",
               position: (151, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (152, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (152, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (153, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (153, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (153, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (154, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (154, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (155, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enable a timer that runs gitea dump to generate backup-files of the\ncurrent gitea database and repositories.\n",
                       position: (156, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (152, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "interval",
                  position: (161, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (161, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (162, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (162, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (162, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (163, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "04:31",
                       position: (163, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (164, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "hourly",
                       position: (164, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (165, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Run a gitea dump at this interval. Runs by default at 04:31 every day.\n\nThe format is described in\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry>.\n",
                       position: (166, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (161, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "backupDir",
                  position: (174, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (174, 21),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (175, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (175, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (175, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (176, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (176, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "stateDir",
                           position: (176, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/dump",
                       position: (176, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (177, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (177, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\"",
                         position: (177, 45),
                        },
                        Raw {
                         content: "$",
                         position: (177, 46),
                        },
                        Raw {
                         content: "{config.",
                         position: (177, 49),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (177, 59),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "stateDir",
                             position: (177, 63),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "}/dump\"",
                         position: (177, 72),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (178, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to the dump files.",
                       position: (178, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (174, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (181, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (181, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (182, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (182, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "enum",
                         position: (182, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "zip",
                           position: (182, 32),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "rar",
                           position: (182, 38),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar",
                           position: (182, 44),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "sz",
                           position: (182, 50),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar.gz",
                           position: (182, 55),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar.xz",
                           position: (182, 64),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar.bz2",
                           position: (182, 73),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar.br",
                           position: (182, 83),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "tar.lz4",
                           position: (182, 92),
                          },
                         ],
                        },
                       ],
                       position: (182, 29),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (183, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "zip",
                       position: (183, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (184, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Archive format used to store the dump file.",
                       position: (184, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (181, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "file",
                  position: (187, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (187, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (188, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (188, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (188, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (188, 31),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "str",
                          position: (188, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (189, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (189, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (190, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Filename to be used for the dump. If `null` a default name is choosen by gitea.",
                       position: (190, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (191, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitea-dump",
                       position: (191, 22),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (187, 25),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (151, 14),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "ssh",
               position: (195, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (196, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (196, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (197, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (197, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (197, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (198, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (198, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (199, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enable external SSH feature.",
                       position: (199, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (196, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "clonePort",
                  position: (202, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (202, 21),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (203, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (203, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "int",
                        position: (203, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (204, 11),
                      },
                     ],
                    },
                    Int {
                     value: 22,
                     position: (204, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "example",
                       position: (205, 11),
                      },
                     ],
                    },
                    Int {
                     value: 2222,
                     position: (205, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (206, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "SSH port displayed in clone URL.\nThe option is required to configure a service when the external visible port\ndiffers from the local listening port i.e. if port forwarding is used.\n",
                       position: (207, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (202, 30),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (195, 13),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "lfs",
               position: (214, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (215, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (215, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (216, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (216, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (216, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (217, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (217, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (218, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enables git-lfs support.",
                       position: (218, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (215, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "contentDir",
                  position: (221, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (221, 22),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (222, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (222, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (222, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (223, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (223, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "stateDir",
                           position: (223, 28),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/data/lfs",
                       position: (223, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (224, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (224, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "\"",
                         position: (224, 45),
                        },
                        Raw {
                         content: "$",
                         position: (224, 46),
                        },
                        Raw {
                         content: "{config.",
                         position: (224, 49),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (224, 59),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "stateDir",
                             position: (224, 63),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "}/data/lfs\"",
                         position: (224, 72),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (225, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Where to store LFS files.",
                       position: (225, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (221, 31),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (214, 13),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "appName",
               position: (229, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (229, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (230, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (230, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (230, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (231, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea: Gitea Service",
                    position: (231, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (232, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Application name.",
                    position: (232, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (229, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "repositoryRoot",
               position: (235, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (235, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (236, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (236, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (236, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (237, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (237, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (237, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/repositories",
                    position: (237, 35),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (238, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (238, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (238, 43),
                     },
                     Raw {
                      content: "$",
                      position: (238, 44),
                     },
                     Raw {
                      content: "{config.",
                      position: (238, 47),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (238, 57),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "stateDir",
                          position: (238, 61),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/repositories\"",
                      position: (238, 70),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (239, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to the git repositories.",
                    position: (239, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (235, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "domain",
               position: (242, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (242, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (243, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (243, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (243, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (244, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (244, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (245, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Domain name of your server.",
                    position: (245, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (242, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rootUrl",
               position: (248, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (248, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (249, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (249, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (249, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (250, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "http://localhost:3000/",
                    position: (250, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (251, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Full public URL of gitea server.",
                    position: (251, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (248, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "httpAddress",
               position: (254, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (254, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (255, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (255, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (255, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (256, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0.0.0.0",
                    position: (256, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (257, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "HTTP listen address.",
                    position: (257, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (254, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "httpPort",
               position: (260, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (260, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (261, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (261, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (261, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (262, 9),
                   },
                  ],
                 },
                 Int {
                  value: 3000,
                  position: (262, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (263, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "HTTP listen port.",
                    position: (263, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (260, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableUnixSocket",
               position: (266, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (266, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (267, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (267, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (267, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (268, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (268, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (269, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configure Gitea to listen on a unix socket instead of the default TCP port.",
                    position: (269, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (266, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cookieSecure",
               position: (272, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (272, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (273, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (273, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (273, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (274, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (274, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (275, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Marks session cookies as \"secure\" as a hint for browsers to only send\nthem via HTTPS. This option is recommend, if gitea is being served over HTTPS.\n",
                    position: (276, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (272, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "staticRootPath",
               position: (281, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (281, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (282, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (282, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "either",
                      position: (282, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (282, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (282, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (282, 39),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (282, 45),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (283, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "gitea",
                   position: (283, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "data",
                     position: (283, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (284, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (284, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "package.data",
                      position: (284, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (285, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/gitea/data",
                    position: (285, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (286, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Upper level of template and static files path.",
                    position: (286, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (281, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mailerPasswordFile",
               position: (289, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (289, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (290, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (290, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (290, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (290, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (290, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (291, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (291, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (292, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/secrets/gitea/mailpw",
                    position: (292, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (293, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to a file containing the SMTP password.",
                    position: (293, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (289, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "disableRegistration",
               position: (296, 7),
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (296, 29),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "the registration lock",
                   position: (296, 45),
                  },
                 ],
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (297, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "By default any user can create an account on this <literal>gitea</literal> instance.\nThis can be disabled by using this option.\n\n<emphasis>Note:</emphasis> please keep in mind that this should be added after the initial\ndeploy unless <link linkend=\"opt-services.gitea.useWizard\">services.gitea.useWizard</link>\nis <literal>true</literal> as the first registered user will be the administrator if\nno install wizard is used.\n",
                    position: (298, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (296, 71),
              },
             ],
             position: (296, 68),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (308, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (308, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (309, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (309, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (309, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "attrsOf",
                      position: (309, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "oneOf",
                        position: (309, 46),
                       },
                       arguments: [
                        List {
                         elements: [
                          Variable {
                           identifier: "bool",
                           position: (309, 54),
                          },
                          Variable {
                           identifier: "int",
                           position: (309, 59),
                          },
                          Variable {
                           identifier: "str",
                           position: (309, 63),
                          },
                         ],
                         position: (309, 52),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (309, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (310, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (310, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (311, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Gitea configuration. Refer to <link xlink:href=\"https://docs.gitea.io/en-us/config-cheat-sheet/\"/>\nfor details on supported values.\n",
                    position: (312, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (315, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (315, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  \"cron.sync_external_users\" = {\n    RUN_AT_START = true;\n    SCHEDULE = \"@every 24h\";\n    UPDATE_EXISTING = true;\n  };\n  mailer = {\n    ENABLED = true;\n    MAILER_TYPE = \"sendmail\";\n    FROM = \"do-not-reply@example.org\";\n    SENDMAIL_PATH = \"",
                      position: (316, 1),
                     },
                     Raw {
                      content: "$",
                      position: (326, 32),
                     },
                     Raw {
                      content: "{pkgs.system-sendmail}/bin/sendmail\";\n  };\n  other = {\n    SHOW_FOOTER_VERSION = false;\n  };\n}\n",
                      position: (326, 35),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (308, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (335, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (335, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (336, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (336, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (336, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (336, 35),
                    },
                   ],
                  },
                  position: (336, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (337, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (337, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (338, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configuration lines appended to the generated gitea configuration file.",
                    position: (338, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (335, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (26, 22),
         },
        ),
       ],
       recursive: false,
       position: (25, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (343, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (343, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (343, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (343, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (344, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (345, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (345, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (345, 25),
                     },
                     Raw {
                      content: "createDatabase",
                      position: (345, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (345, 52),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (345, 56),
                       },
                       Raw {
                        content: "user",
                        position: (345, 65),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (345, 73),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (345, 77),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (345, 70),
                  },
                 ],
                 position: (345, 49),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (346, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitea.database.user must match services.gitea.user if the database is to be automatically provisioned",
                   position: (346, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (345, 7),
             },
            ],
            position: (344, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (350, 5),
             },
             Raw {
              content: "gitea",
              position: (350, 14),
             },
             Raw {
              content: "settings",
              position: (350, 20),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "database",
                 position: (351, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (351, 18),
               },
               arguments: [
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "DB_TYPE",
                        position: (353, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (353, 21),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (353, 25),
                        },
                        Raw {
                         content: "type",
                         position: (353, 34),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (352, 9),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (355, 10),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      Variable {
                       identifier: "useMysql",
                       position: (355, 16),
                      },
                      Variable {
                       identifier: "usePostgresql",
                       position: (355, 28),
                      },
                     ],
                     position: (355, 25),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "HOST",
                          position: (356, 11),
                         },
                        ],
                       },
                       IfThenElse {
                        predicate: BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (356, 21),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "database",
                              position: (356, 25),
                             },
                             Raw {
                              content: "socket",
                              position: (356, 34),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (356, 44),
                          },
                         ],
                         position: (356, 41),
                        },
                        then: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (356, 54),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "database",
                            position: (356, 58),
                           },
                           Raw {
                            content: "socket",
                            position: (356, 67),
                           },
                          ],
                         },
                         default: None,
                        },
                        else_: BinaryOperation {
                         operator: Addition,
                         operands: [
                          BinaryOperation {
                           operator: Addition,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (356, 79),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "database",
                                position: (356, 83),
                               },
                               Raw {
                                content: "host",
                                position: (356, 92),
                               },
                              ],
                             },
                             default: None,
                            },
                            String {
                             parts: [
                              Raw {
                               content: ":",
                               position: (356, 100),
                              },
                             ],
                            },
                           ],
                           position: (356, 97),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "toString",
                            position: (356, 105),
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (356, 114),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "database",
                                position: (356, 118),
                               },
                               Raw {
                                content: "port",
                                position: (356, 127),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         ],
                         position: (356, 103),
                        },
                        position: (356, 18),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "NAME",
                          position: (357, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (357, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (357, 22),
                          },
                          Raw {
                           content: "name",
                           position: (357, 31),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "USER",
                          position: (358, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (358, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (358, 22),
                          },
                          Raw {
                           content: "user",
                           position: (358, 31),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "PASSWD",
                          position: (359, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "#dbpass#",
                          position: (359, 21),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (355, 43),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (361, 10),
                   },
                   arguments: [
                    Variable {
                     identifier: "useSqlite",
                     position: (361, 15),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "PATH",
                          position: (362, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (362, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (362, 22),
                          },
                          Raw {
                           content: "path",
                           position: (362, 31),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (361, 25),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (364, 10),
                   },
                   arguments: [
                    Variable {
                     identifier: "usePostgresql",
                     position: (364, 15),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "SSL_MODE",
                          position: (365, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "disable",
                          position: (365, 23),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (364, 29),
                    },
                   ],
                  },
                 ],
                 position: (351, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "repository",
                 position: (369, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ROOT",
                    position: (370, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (370, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "repositoryRoot",
                     position: (370, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (369, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "server",
                 position: (373, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (373, 16),
               },
               arguments: [
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "DOMAIN",
                        position: (375, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (375, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "domain",
                         position: (375, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "STATIC_ROOT_PATH",
                        position: (376, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (376, 30),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (376, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "staticRootPath",
                           position: (376, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "LFS_JWT_SECRET",
                        position: (377, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "#lfsjwtsecret#",
                        position: (377, 29),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ROOT_URL",
                        position: (378, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (378, 22),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "rootUrl",
                         position: (378, 26),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (374, 9),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (380, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (380, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "enableUnixSocket",
                        position: (380, 19),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "PROTOCOL",
                          position: (381, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "unix",
                          position: (381, 23),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "HTTP_ADDR",
                          position: (382, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "/run/gitea/gitea.sock",
                          position: (382, 24),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (380, 36),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (384, 10),
                   },
                   arguments: [
                    UnaryOperation {
                     operator: Not,
                     operand: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (384, 17),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "enableUnixSocket",
                         position: (384, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     position: (384, 16),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "HTTP_ADDR",
                          position: (385, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (385, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "httpAddress",
                           position: (385, 27),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "HTTP_PORT",
                          position: (386, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (386, 23),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "httpPort",
                           position: (386, 27),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (384, 39),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (388, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (388, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "ssh",
                        position: (388, 19),
                       },
                       Raw {
                        content: "enable",
                        position: (388, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "DISABLE_SSH",
                          position: (389, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "false",
                        position: (389, 25),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "SSH_PORT",
                          position: (390, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (390, 22),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "ssh",
                           position: (390, 26),
                          },
                          Raw {
                           content: "clonePort",
                           position: (390, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (388, 30),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (392, 10),
                   },
                   arguments: [
                    UnaryOperation {
                     operator: Not,
                     operand: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (392, 17),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "ssh",
                         position: (392, 21),
                        },
                        Raw {
                         content: "enable",
                         position: (392, 25),
                        },
                       ],
                      },
                      default: None,
                     },
                     position: (392, 16),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "DISABLE_SSH",
                          position: (393, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "true",
                        position: (393, 25),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (392, 33),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (395, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (395, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "lfs",
                        position: (395, 19),
                       },
                       Raw {
                        content: "enable",
                        position: (395, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "LFS_START_SERVER",
                          position: (396, 11),
                         },
                        ],
                       },
                       Variable {
                        identifier: "true",
                        position: (396, 30),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "LFS_CONTENT_PATH",
                          position: (397, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (397, 30),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "lfs",
                           position: (397, 34),
                          },
                          Raw {
                           content: "contentDir",
                           position: (397, 38),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                     ],
                     recursive: false,
                     position: (395, 30),
                    },
                   ],
                  },
                 ],
                 position: (373, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "session",
                 position: (402, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "COOKIE_NAME",
                    position: (403, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "session",
                    position: (403, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "COOKIE_SECURE",
                    position: (404, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (404, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "cookieSecure",
                     position: (404, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (402, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "security",
                 position: (407, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SECRET_KEY",
                    position: (408, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "#secretkey#",
                    position: (408, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "INTERNAL_TOKEN",
                    position: (409, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "#internaltoken#",
                    position: (409, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "INSTALL_LOCK",
                    position: (410, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (410, 24),
                 },
                ),
               ],
               recursive: false,
               position: (407, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "log",
                 position: (413, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ROOT_PATH",
                    position: (414, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (414, 21),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "log",
                     position: (414, 25),
                    },
                    Raw {
                     content: "rootPath",
                     position: (414, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LEVEL",
                    position: (415, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (415, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "log",
                     position: (415, 21),
                    },
                    Raw {
                     content: "level",
                     position: (415, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (413, 13),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "service",
                 position: (418, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "DISABLE_REGISTRATION",
                    position: (419, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (419, 32),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "disableRegistration",
                     position: (419, 36),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (418, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "mailer",
                 position: (422, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (422, 16),
               },
               arguments: [
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (422, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mailerPasswordFile",
                      position: (422, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (422, 48),
                  },
                 ],
                 position: (422, 45),
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PASSWD",
                      position: (423, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "#mailerpass#",
                      position: (423, 19),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (422, 54),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "oauth2",
                 position: (426, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "JWT_SECRET",
                    position: (427, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "#oauth2jwtsecret#",
                    position: (427, 23),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (426, 16),
              },
             ),
            ],
            recursive: false,
            position: (350, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (431, 5),
             },
             Raw {
              content: "postgresql",
              position: (431, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (431, 27),
            },
            arguments: [
             BinaryOperation {
              operator: LogicalAnd,
              operands: [
               Variable {
                identifier: "usePostgresql",
                position: (431, 42),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (431, 59),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "database",
                   position: (431, 63),
                  },
                  Raw {
                   content: "createDatabase",
                   position: (431, 72),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (431, 56),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (432, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (432, 16),
                 },
                 arguments: [
                  Variable {
                   identifier: "true",
                   position: (432, 26),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureDatabases",
                   position: (434, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (434, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (434, 31),
                     },
                     Raw {
                      content: "name",
                      position: (434, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (434, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (435, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (436, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (436, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (436, 22),
                        },
                        Raw {
                         content: "user",
                         position: (436, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ensurePermissions",
                        position: (437, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "DATABASE ",
                              position: (437, 34),
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (437, 45),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "database",
                                  position: (437, 49),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (437, 58),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                            ],
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (437, 68),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (437, 31),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (436, 9),
                  },
                 ],
                 position: (435, 21),
                },
               ),
              ],
              recursive: false,
              position: (431, 88),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (442, 5),
             },
             Raw {
              content: "mysql",
              position: (442, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (442, 22),
            },
            arguments: [
             BinaryOperation {
              operator: LogicalAnd,
              operands: [
               Variable {
                identifier: "useMysql",
                position: (442, 37),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (442, 49),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "database",
                   position: (442, 53),
                  },
                  Raw {
                   content: "createDatabase",
                   position: (442, 62),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (442, 46),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (443, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (443, 16),
                 },
                 arguments: [
                  Variable {
                   identifier: "true",
                   position: (443, 26),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "package",
                   position: (444, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (444, 17),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (444, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mariadb",
                      position: (444, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureDatabases",
                   position: (446, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (446, 27),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "database",
                      position: (446, 31),
                     },
                     Raw {
                      content: "name",
                      position: (446, 40),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (446, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (447, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (448, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (448, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (448, 22),
                        },
                        Raw {
                         content: "user",
                         position: (448, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ensurePermissions",
                        position: (449, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (449, 36),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "database",
                                  position: (449, 40),
                                 },
                                 Raw {
                                  content: "name",
                                  position: (449, 49),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                             Raw {
                              content: ".*",
                              position: (449, 54),
                             },
                            ],
                           },
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "ALL PRIVILEGES",
                           position: (449, 61),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (449, 31),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (448, 9),
                  },
                 ],
                 position: (447, 21),
                },
               ),
              ],
              recursive: false,
              position: (442, 78),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (454, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (454, 13),
             },
             Raw {
              content: "rules",
              position: (454, 22),
             },
            ],
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "d '",
                position: (455, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (455, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dump",
                    position: (455, 17),
                   },
                   Raw {
                    content: "backupDir",
                    position: (455, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (455, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (455, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (455, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (455, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (456, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (456, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dump",
                    position: (456, 17),
                   },
                   Raw {
                    content: "backupDir",
                    position: (456, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (456, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (456, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (456, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (456, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Z '",
                position: (457, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (457, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dump",
                    position: (457, 17),
                   },
                   Raw {
                    content: "backupDir",
                    position: (457, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' - ",
                position: (457, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (457, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (457, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (457, 47),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (458, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (458, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "lfs",
                    position: (458, 17),
                   },
                   Raw {
                    content: "contentDir",
                    position: (458, 21),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (458, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (458, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (458, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (458, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (459, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (459, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "lfs",
                    position: (459, 17),
                   },
                   Raw {
                    content: "contentDir",
                    position: (459, 21),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (459, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (459, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (459, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (459, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Z '",
                position: (460, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (460, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "lfs",
                    position: (460, 17),
                   },
                   Raw {
                    content: "contentDir",
                    position: (460, 21),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' - ",
                position: (460, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (460, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (460, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (460, 47),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (461, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (461, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "repositoryRoot",
                    position: (461, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (461, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (461, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (461, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (461, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (462, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (462, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "repositoryRoot",
                    position: (462, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (462, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (462, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (462, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (462, 50),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Z '",
                position: (463, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (463, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "repositoryRoot",
                    position: (463, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' - ",
                position: (463, 32),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (463, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (463, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (463, 47),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (464, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (464, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (464, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (464, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (464, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (464, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (464, 44),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (465, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (465, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (465, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/conf' 0750 ",
                position: (465, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (465, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (465, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (465, 49),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (466, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (466, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (466, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom' 0750 ",
                position: (466, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (466, 42),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (466, 46),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (466, 51),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (467, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (467, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (467, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom/conf' 0750 ",
                position: (467, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (467, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (467, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (467, 56),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d '",
                position: (468, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (468, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (468, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log' 0750 ",
                position: (468, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (468, 39),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (468, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (468, 48),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (469, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (469, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (469, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' 0750 ",
                position: (469, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (469, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (469, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (469, 44),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (470, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (470, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (470, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/.ssh' 0700 ",
                position: (470, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (470, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (470, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (470, 49),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (471, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (471, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (471, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/conf' 0750 ",
                position: (471, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (471, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (471, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (471, 49),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (472, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (472, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (472, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom' 0750 ",
                position: (472, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (472, 42),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (472, 46),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (472, 51),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (473, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (473, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (473, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom/conf' 0750 ",
                position: (473, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (473, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (473, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (473, 56),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z '",
                position: (474, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (474, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (474, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log' 0750 ",
                position: (474, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (474, 39),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (474, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (474, 48),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Z '",
                position: (475, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (475, 13),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (475, 17),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "' - ",
                position: (475, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (475, 32),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (475, 36),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " gitea - -",
                position: (475, 41),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ '",
                position: (479, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (479, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (479, 18),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/conf/locale' - - - - ",
                position: (479, 27),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitea",
                  position: (479, 51),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "out",
                    position: (479, 57),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/locale",
                position: (479, 61),
               },
              ],
             },
            ],
            position: (454, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (482, 5),
             },
             Raw {
              content: "services",
              position: (482, 13),
             },
             Raw {
              content: "gitea",
              position: (482, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (483, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "gitea",
                 position: (483, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (484, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (484, 18),
                    },
                   ],
                  },
                 ],
                 position: (484, 15),
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (484, 39),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "optional",
                       position: (484, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "usePostgresql",
                     position: (484, 52),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "postgresql.service",
                       position: (484, 67),
                      },
                     ],
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (484, 90),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "optional",
                       position: (484, 94),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "useMysql",
                     position: (484, 103),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mysql.service",
                       position: (484, 113),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (484, 87),
                },
               ],
               position: (484, 36),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (485, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (485, 21),
                  },
                 ],
                },
               ],
               position: (485, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (486, 7),
                },
               ],
              },
              List {
               elements: [
                Variable {
                 identifier: "gitea",
                 position: (486, 16),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (486, 22),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "git",
                    position: (486, 27),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (486, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (495, 7),
                },
               ],
              },
              LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "runConfig",
                    position: (496, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (496, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (496, 28),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/app.ini",
                    position: (496, 37),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "secretKey",
                    position: (497, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (497, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (497, 28),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/secret_key",
                    position: (497, 37),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "oauth2JwtSecret",
                    position: (498, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (498, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (498, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/oauth2_jwt_secret",
                    position: (498, 43),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "oldLfsJwtSecret",
                    position: (499, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (499, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (499, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/jwt_secret",
                    position: (499, 43),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "lfsJwtSecret",
                    position: (500, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (500, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (500, 31),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/lfs_jwt_secret",
                    position: (500, 40),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internalToken",
                    position: (501, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (501, 28),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stateDir",
                        position: (501, 32),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/custom/conf/internal_token",
                    position: (501, 41),
                   },
                  ],
                 },
                ),
               ],
               target: String {
                parts: [
                 Raw {
                  content: "# copy custom configuration and generate a random secret key if needed\n",
                  position: (503, 1),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "optionalString",
                    position: (504, 11),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (504, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "useWizard",
                          position: (504, 31),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "false",
                       position: (504, 44),
                      },
                     ],
                     position: (504, 41),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "function gitea_setup {\n  cp -f ",
                       position: (505, 1),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "configFile",
                        position: (506, 21),
                       },
                      },
                      Raw {
                       content: " ",
                       position: (506, 32),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "runConfig",
                        position: (506, 35),
                       },
                      },
                      Raw {
                       content: "\n\n  if [ ! -e ",
                       position: (506, 45),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "secretKey",
                        position: (508, 25),
                       },
                      },
                      Raw {
                       content: " ]; then\n      ",
                       position: (508, 35),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "gitea",
                        position: (509, 19),
                       },
                      },
                      Raw {
                       content: "/bin/gitea generate secret SECRET_KEY > ",
                       position: (509, 25),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "secretKey",
                        position: (509, 67),
                       },
                      },
                      Raw {
                       content: "\n  fi\n\n  # Migrate LFS_JWT_SECRET filename\n  if [[ -e ",
                       position: (509, 77),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "oldLfsJwtSecret",
                        position: (513, 24),
                       },
                      },
                      Raw {
                       content: " && ! -e ",
                       position: (513, 40),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "lfsJwtSecret",
                        position: (513, 51),
                       },
                      },
                      Raw {
                       content: " ]]; then\n      mv ",
                       position: (513, 64),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "oldLfsJwtSecret",
                        position: (514, 22),
                       },
                      },
                      Raw {
                       content: " ",
                       position: (514, 38),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "lfsJwtSecret",
                        position: (514, 41),
                       },
                      },
                      Raw {
                       content: "\n  fi\n\n  if [ ! -e ",
                       position: (514, 54),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "oauth2JwtSecret",
                        position: (517, 25),
                       },
                      },
                      Raw {
                       content: " ]; then\n      ",
                       position: (517, 41),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "gitea",
                        position: (518, 19),
                       },
                      },
                      Raw {
                       content: "/bin/gitea generate secret JWT_SECRET > ",
                       position: (518, 25),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "oauth2JwtSecret",
                        position: (518, 67),
                       },
                      },
                      Raw {
                       content: "\n  fi\n\n  if [ ! -e ",
                       position: (518, 83),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "lfsJwtSecret",
                        position: (521, 25),
                       },
                      },
                      Raw {
                       content: " ]; then\n      ",
                       position: (521, 38),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "gitea",
                        position: (522, 19),
                       },
                      },
                      Raw {
                       content: "/bin/gitea generate secret LFS_JWT_SECRET > ",
                       position: (522, 25),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "lfsJwtSecret",
                        position: (522, 71),
                       },
                      },
                      Raw {
                       content: "\n  fi\n\n  if [ ! -e ",
                       position: (522, 84),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "internalToken",
                        position: (525, 25),
                       },
                      },
                      Raw {
                       content: " ]; then\n      ",
                       position: (525, 39),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "gitea",
                        position: (526, 19),
                       },
                      },
                      Raw {
                       content: "/bin/gitea generate secret INTERNAL_TOKEN > ",
                       position: (526, 25),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "internalToken",
                        position: (526, 71),
                       },
                      },
                      Raw {
                       content: "\n  fi\n\n  SECRETKEY=\"$(head -n1 ",
                       position: (526, 85),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "secretKey",
                        position: (529, 37),
                       },
                      },
                      Raw {
                       content: ")\"\n  DBPASS=\"$(head -n1 ",
                       position: (529, 47),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (530, 34),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (530, 38),
                          },
                          Raw {
                           content: "passwordFile",
                           position: (530, 47),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: ")\"\n  OAUTH2JWTSECRET=\"$(head -n1 ",
                       position: (530, 60),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "oauth2JwtSecret",
                        position: (531, 43),
                       },
                      },
                      Raw {
                       content: ")\"\n  LFSJWTSECRET=\"$(head -n1 ",
                       position: (531, 59),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "lfsJwtSecret",
                        position: (532, 40),
                       },
                      },
                      Raw {
                       content: ")\"\n  INTERNALTOKEN=\"$(head -n1 ",
                       position: (532, 53),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "internalToken",
                        position: (533, 41),
                       },
                      },
                      Raw {
                       content: ")\"\n  ",
                       position: (533, 55),
                      },
                      Expression {
                       expression: IfThenElse {
                        predicate: BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (534, 19),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "mailerPasswordFile",
                              position: (534, 23),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (534, 45),
                          },
                         ],
                         position: (534, 42),
                        },
                        then: String {
                         parts: [
                          Raw {
                           content: "MAILERPASSWORD=\"#mailerpass#\"\n",
                           position: (535, 1),
                          },
                         ],
                        },
                        else_: String {
                         parts: [
                          Raw {
                           content: "MAILERPASSWORD=\"$(head -n1 ",
                           position: (537, 1),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (537, 44),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "mailerPasswordFile",
                               position: (537, 48),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: " || :)\"\n",
                           position: (537, 67),
                          },
                         ],
                        },
                        position: (534, 15),
                       },
                      },
                      Raw {
                       content: "\n  sed -e \"s,#secretkey#,$SECRETKEY,g\" \\\n      -e \"s,#dbpass#,$DBPASS,g\" \\\n      -e \"s,#oauth2jwtsecret#,$OAUTH2JWTSECRET,g\" \\\n      -e \"s,#lfsjwtsecret#,$LFSJWTSECRET,g\" \\\n      -e \"s,#internaltoken#,$INTERNALTOKEN,g\" \\\n      -e \"s,#mailerpass#,$MAILERPASSWORD,g\" \\\n      -i ",
                       position: (538, 16),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "runConfig",
                        position: (545, 22),
                       },
                      },
                      Raw {
                       content: "\n}\n(umask 027; gitea_setup)\n",
                       position: (545, 32),
                      },
                     ],
                    },
                   ],
                  },
                 },
                 Raw {
                  content: "\n\n# run migrations/init the database\n",
                  position: (548, 12),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "gitea",
                   position: (551, 11),
                  },
                 },
                 Raw {
                  content: "/bin/gitea migrate\n\n# update all hooks' binary paths\n",
                  position: (551, 17),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "gitea",
                   position: (554, 11),
                  },
                 },
                 Raw {
                  content: "/bin/gitea admin regenerate hooks\n\n# update command option in authorized_keys\nif [ -r ",
                  position: (554, 17),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (557, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "stateDir",
                      position: (557, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/.ssh/authorized_keys ]\nthen\n  ",
                  position: (557, 32),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "gitea",
                   position: (559, 13),
                  },
                 },
                 Raw {
                  content: "/bin/gitea admin regenerate keys\nfi\n",
                  position: (559, 19),
                 },
                ],
               },
               position: (495, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (563, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (564, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                    position: (564, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (565, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (565, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (565, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (566, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea",
                    position: (566, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (567, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (567, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "stateDir",
                     position: (567, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (568, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: Variable {
                     identifier: "gitea",
                     position: (568, 24),
                    },
                   },
                   Raw {
                    content: "/bin/gitea web --pid /run/gitea/gitea.pid",
                    position: (568, 30),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (569, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "always",
                    position: (569, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectory",
                    position: (571, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitea",
                    position: (571, 29),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectoryMode",
                    position: (572, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0755",
                    position: (572, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ReadWritePaths",
                    position: (574, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (574, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "dump",
                       position: (574, 32),
                      },
                      Raw {
                       content: "backupDir",
                       position: (574, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (574, 47),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "repositoryRoot",
                       position: (574, 51),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (574, 66),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "stateDir",
                       position: (574, 70),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (574, 79),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "lfs",
                       position: (574, 83),
                      },
                      Raw {
                       content: "contentDir",
                       position: (574, 87),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                  position: (574, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "UMask",
                    position: (575, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0027",
                    position: (575, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "CapabilityBoundingSet",
                    position: (577, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "NoNewPrivileges",
                    position: (579, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (579, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectSystem",
                    position: (581, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "strict",
                    position: (581, 26),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHome",
                    position: (582, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (582, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateTmp",
                    position: (583, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (583, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateDevices",
                    position: (584, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (584, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateUsers",
                    position: (585, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (585, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHostname",
                    position: (586, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (586, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectClock",
                    position: (587, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (587, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelTunables",
                    position: (588, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (588, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelModules",
                    position: (589, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (589, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelLogs",
                    position: (590, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (590, 29),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectControlGroups",
                    position: (591, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (591, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictAddressFamilies",
                    position: (592, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "AF_UNIX AF_INET AF_INET6",
                      position: (592, 38),
                     },
                    ],
                   },
                  ],
                  position: (592, 35),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LockPersonality",
                    position: (593, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (593, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "MemoryDenyWriteExecute",
                    position: (594, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (594, 34),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictRealtime",
                    position: (595, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (595, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictSUIDSGID",
                    position: (596, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (596, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateMounts",
                    position: (597, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (597, 25),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallArchitectures",
                    position: (599, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "native",
                    position: (599, 36),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallFilter",
                    position: (600, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "~@clock @cpu-emulation @debug @keyring @memlock @module @mount @obsolete @raw-io @reboot @resources @setuid @swap",
                    position: (600, 29),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (563, 23),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (603, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "USER",
                    position: (604, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (604, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (604, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "HOME",
                    position: (605, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (605, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "stateDir",
                     position: (605, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "GITEA_WORK_DIR",
                    position: (606, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (606, 26),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "stateDir",
                     position: (606, 30),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (603, 21),
              },
             ),
            ],
            recursive: false,
            position: (482, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (610, 5),
             },
             Raw {
              content: "users",
              position: (610, 11),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (610, 19),
            },
            arguments: [
             BinaryOperation {
              operator: EqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (610, 25),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "user",
                   position: (610, 29),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "gitea",
                  position: (610, 38),
                 },
                ],
               },
              ],
              position: (610, 34),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "gitea",
                   position: (611, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (612, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Gitea Service",
                      position: (612, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "home",
                      position: (613, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (613, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "stateDir",
                       position: (613, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "useDefaultShell",
                      position: (614, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (614, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "group",
                      position: (615, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "gitea",
                      position: (615, 18),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "isSystemUser",
                      position: (616, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (616, 24),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (611, 15),
                },
               ),
              ],
              recursive: false,
              position: (610, 46),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (620, 5),
             },
             Raw {
              content: "groups",
              position: (620, 11),
             },
             Raw {
              content: "gitea",
              position: (620, 18),
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (620, 26),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "warnings",
              position: (622, 5),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (623, 7),
              },
              arguments: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (623, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "database",
                     position: (623, 21),
                    },
                    Raw {
                     content: "password",
                     position: (623, 30),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [],
                 },
                ],
                position: (623, 39),
               },
               String {
                parts: [
                 Raw {
                  content: "config.services.gitea.database.password will be stored as plaintext in the Nix store. Use database.passwordFile instead.",
                  position: (623, 47),
                 },
                ],
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (624, 7),
              },
              arguments: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (624, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "extraConfig",
                     position: (624, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "null",
                  position: (624, 36),
                 },
                ],
                position: (624, 33),
               },
               String {
                parts: [
                 Raw {
                  content: "services.gitea.`extraConfig` is deprecated, please use services.gitea.`settings`.\n",
                  position: (625, 1),
                 },
                ],
               },
              ],
             },
            ],
            position: (623, 169),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (629, 5),
             },
             Raw {
              content: "gitea",
              position: (629, 14),
             },
             Raw {
              content: "database",
              position: (629, 20),
             },
             Raw {
              content: "passwordFile",
              position: (629, 29),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (630, 8),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "toString",
               position: (630, 19),
              },
              arguments: [
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (630, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "writeTextFile",
                    position: (630, 34),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (631, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitea-database-password",
                       position: (631, 17),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "text",
                       position: (632, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (632, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (632, 20),
                       },
                       Raw {
                        content: "password",
                        position: (632, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (630, 48),
                 },
                ],
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (635, 5),
             },
             Raw {
              content: "services",
              position: (635, 13),
             },
             Raw {
              content: "gitea-dump",
              position: (635, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (635, 35),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (635, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "dump",
                 position: (635, 44),
                },
                Raw {
                 content: "enable",
                 position: (635, 49),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (636, 8),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitea dump",
                   position: (636, 23),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (637, 8),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitea.service",
                     position: (637, 19),
                    },
                   ],
                  },
                 ],
                 position: (637, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (638, 8),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "default.target",
                     position: (638, 22),
                    },
                   ],
                  },
                 ],
                 position: (638, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (639, 8),
                  },
                 ],
                },
                List {
                 elements: [
                  Variable {
                   identifier: "gitea",
                   position: (639, 17),
                  },
                 ],
                 position: (639, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "environment",
                   position: (641, 8),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "USER",
                      position: (642, 10),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (642, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (642, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "HOME",
                      position: (643, 10),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (643, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "stateDir",
                       position: (643, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "GITEA_WORK_DIR",
                      position: (644, 10),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (644, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "stateDir",
                       position: (644, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (641, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (647, 8),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Type",
                      position: (648, 10),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "oneshot",
                      position: (648, 18),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "User",
                      position: (649, 10),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (649, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (649, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (650, 10),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     String {
                      parts: [
                       Expression {
                        expression: Variable {
                         identifier: "gitea",
                         position: (650, 25),
                        },
                       },
                       Raw {
                        content: "/bin/gitea dump --type ",
                        position: (650, 31),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (650, 56),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "dump",
                            position: (650, 60),
                           },
                           Raw {
                            content: "type",
                            position: (650, 65),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionalString",
                       position: (650, 74),
                      },
                      arguments: [
                       BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (650, 90),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "dump",
                             position: (650, 94),
                            },
                            Raw {
                             content: "file",
                             position: (650, 99),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (650, 107),
                         },
                        ],
                        position: (650, 104),
                       },
                       String {
                        parts: [
                         Raw {
                          content: " --file ",
                          position: (650, 114),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (650, 124),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "dump",
                              position: (650, 128),
                             },
                             Raw {
                              content: "file",
                              position: (650, 133),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                        ],
                       },
                      ],
                     },
                    ],
                    position: (650, 72),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "WorkingDirectory",
                      position: (651, 10),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (651, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "dump",
                       position: (651, 33),
                      },
                      Raw {
                       content: "backupDir",
                       position: (651, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (647, 24),
                },
               ),
              ],
              recursive: false,
              position: (635, 56),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (655, 5),
             },
             Raw {
              content: "timers",
              position: (655, 13),
             },
             Raw {
              content: "gitea-dump",
              position: (655, 20),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (655, 33),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (655, 38),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "dump",
                 position: (655, 42),
                },
                Raw {
                 content: "enable",
                 position: (655, 47),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (656, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Update timer for gitea-dump",
                   position: (656, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "partOf",
                   position: (657, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitea-dump.service",
                     position: (657, 19),
                    },
                   ],
                  },
                 ],
                 position: (657, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (658, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "timers.target",
                     position: (658, 21),
                    },
                   ],
                  },
                 ],
                 position: (658, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "timerConfig",
                   position: (659, 7),
                  },
                  Raw {
                   content: "OnCalendar",
                   position: (659, 19),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (659, 32),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dump",
                    position: (659, 36),
                   },
                   Raw {
                    content: "interval",
                    position: (659, 41),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (655, 54),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (343, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (662, 3),
        },
        Raw {
         content: "maintainers",
         position: (662, 8),
        },
       ],
      },
      With {
       expression: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (662, 27),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "maintainers",
           position: (662, 31),
          },
         ],
        },
        default: None,
       },
       target: List {
        elements: [
         Variable {
          identifier: "srhb",
          position: (662, 46),
         },
         Variable {
          identifier: "ma27",
          position: (662, 51),
         },
        ],
        position: (662, 44),
       },
       position: (662, 22),
      },
     ),
    ],
    recursive: false,
    position: (24, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}