---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "utils",
    default: None,
   },
   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: "gitlab",
         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: "gitlab",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "ruby",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (9, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "packages",
         position: (9, 14),
        },
        Raw {
         content: "gitlab",
         position: (9, 23),
        },
        Raw {
         content: "ruby",
         position: (9, 30),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "postgresqlPackage",
        position: (11, 3),
       },
      ],
     },
     IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (11, 26),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "services",
          position: (11, 33),
         },
         Raw {
          content: "postgresql",
          position: (11, 42),
         },
         Raw {
          content: "enable",
          position: (11, 53),
         },
        ],
       },
       default: None,
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (12, 25),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "services",
          position: (12, 32),
         },
         Raw {
          content: "postgresql",
          position: (12, 41),
         },
         Raw {
          content: "package",
          position: (12, 52),
         },
        ],
       },
       default: None,
      },
      else_: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (14, 25),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "postgresql_12",
          position: (14, 30),
         },
        ],
       },
       default: None,
      },
      position: (11, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlabSocket",
        position: (16, 3),
       },
      ],
     },
     String {
      parts: [
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (16, 21),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "statePath",
            position: (16, 25),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/tmp/sockets/gitlab.socket",
        position: (16, 35),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitalySocket",
        position: (17, 3),
       },
      ],
     },
     String {
      parts: [
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (17, 21),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "statePath",
            position: (17, 25),
           },
          ],
         },
         default: None,
        },
       },
       Raw {
        content: "/tmp/sockets/gitaly.socket",
        position: (17, 35),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pathUrlQuote",
        position: (18, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "url",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "replaceStrings",
        position: (18, 23),
       },
       arguments: [
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "/",
             position: (18, 40),
            },
           ],
          },
         ],
         position: (18, 38),
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "%2F",
             position: (18, 46),
            },
           ],
          },
         ],
         position: (18, 44),
        },
        Variable {
         identifier: "url",
         position: (18, 52),
        },
       ],
      },
      position: (18, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "databaseConfig",
        position: (20, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "production",
           position: (21, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "adapter",
                position: (22, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "postgresql",
                position: (22, 18),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "database",
                position: (23, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (23, 18),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "databaseName",
                 position: (23, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (24, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (24, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "databaseHost",
                 position: (24, 18),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "username",
                position: (25, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (25, 18),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "databaseUsername",
                 position: (25, 22),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "encoding",
                position: (26, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "utf8",
                position: (26, 19),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "pool",
                position: (27, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (27, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "databasePool",
                 position: (27, 18),
                },
               ],
              },
              default: None,
             },
            ),
           ],
           recursive: false,
           position: (21, 18),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (28, 10),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraDatabaseConfig",
              position: (28, 14),
             },
            ],
           },
           default: None,
          },
         ],
         position: (28, 7),
        },
       ),
      ],
      recursive: false,
      position: (20, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "databaseActuallyCreateLocally",
        position: (32, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (32, 35),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "databaseCreateLocally",
           position: (32, 39),
          },
         ],
        },
        default: None,
       },
       BinaryOperation {
        operator: EqualTo,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (32, 64),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "databaseHost",
             position: (32, 68),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [],
         },
        ],
        position: (32, 81),
       },
      ],
      position: (32, 61),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitalyToml",
        position: (34, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (34, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (34, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "gitaly.toml",
          position: (34, 32),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "socket_path = \"",
          position: (35, 1),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (35, 22),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "escape",
               position: (35, 26),
              },
             ],
            },
            default: None,
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "\"",
                 position: (35, 35),
                },
               ],
              },
             ],
             position: (35, 33),
            },
            Variable {
             identifier: "gitalySocket",
             position: (35, 40),
            },
           ],
          },
         },
         Raw {
          content: "\"\nbin_dir = \"",
          position: (35, 53),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (36, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "packages",
              position: (36, 22),
             },
             Raw {
              content: "gitaly",
              position: (36, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/bin\"\nprometheus_listen_addr = \"localhost:9236\"\n\n[git]\nbin_path = \"",
          position: (36, 38),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (40, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "git",
              position: (40, 24),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/bin/git\"\n\n[gitaly-ruby]\ndir = \"",
          position: (40, 28),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (43, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "packages",
              position: (43, 18),
             },
             Raw {
              content: "gitaly",
              position: (43, 27),
             },
             Raw {
              content: "ruby",
              position: (43, 34),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\n\n[gitlab-shell]\ndir = \"",
          position: (43, 39),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (46, 14),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "packages",
              position: (46, 18),
             },
             Raw {
              content: "gitlab-shell",
              position: (46, 27),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\"\n\n[hooks]\ncustom_hooks_dir = \"",
          position: (46, 40),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (49, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "statePath",
              position: (49, 31),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/custom_hooks\"\n\n[gitlab]\nsecret_file = \"",
          position: (49, 41),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (52, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "statePath",
              position: (52, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/gitlab_shell_secret\"\nurl = \"http+unix://",
          position: (52, 36),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "pathUrlQuote",
            position: (53, 26),
           },
           arguments: [
            Variable {
             identifier: "gitlabSocket",
             position: (53, 39),
            },
           ],
          },
         },
         Raw {
          content: "\"\n\n[gitlab.http-settings]\nself_signed_cert = false\n\n",
          position: (53, 52),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (58, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (58, 25),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (58, 30),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrs",
                position: (58, 42),
               },
               arguments: [
                Function {
                 argument: Some(
                  "k",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "v",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "[[storage]]\nname = \"",
                     position: (59, 1),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (60, 15),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "escape",
                          position: (60, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "\"",
                            position: (60, 28),
                           },
                          ],
                         },
                        ],
                        position: (60, 26),
                       },
                       Variable {
                        identifier: "k",
                        position: (60, 33),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\"\npath = \"",
                     position: (60, 35),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (61, 15),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "escape",
                          position: (61, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "\"",
                            position: (61, 28),
                           },
                          ],
                         },
                        ],
                        position: (61, 26),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "v",
                         position: (61, 33),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "path",
                           position: (61, 35),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\"\n",
                     position: (61, 40),
                    },
                   ],
                  },
                  position: (58, 55),
                 },
                 position: (58, 52),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (62, 9),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (62, 22),
                   },
                   Raw {
                    content: "repositories",
                    position: (62, 33),
                   },
                   Raw {
                    content: "storages",
                    position: (62, 46),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (62, 57),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlabShellConfig",
        position: (65, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "flip",
       position: (65, 23),
      },
      arguments: [
       Variable {
        identifier: "recursiveUpdate",
        position: (65, 28),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (65, 44),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "extraShellConfig",
           position: (65, 48),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "user",
             position: (66, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (66, 12),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "user",
              position: (66, 16),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "gitlab_url",
             position: (67, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "http+unix://",
             position: (67, 19),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "pathUrlQuote",
               position: (67, 33),
              },
              arguments: [
               Variable {
                identifier: "gitlabSocket",
                position: (67, 46),
               },
              ],
             },
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "http_settings",
             position: (68, 5),
            },
            Raw {
             content: "self_signed_cert",
             position: (68, 19),
            },
           ],
          },
          Variable {
           identifier: "false",
           position: (68, 38),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "repos_path",
             position: (69, 5),
            },
           ],
          },
          String {
           parts: [
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (69, 21),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "statePath",
                 position: (69, 25),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/repositories",
             position: (69, 35),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "secret_file",
             position: (70, 5),
            },
           ],
          },
          String {
           parts: [
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (70, 22),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "statePath",
                 position: (70, 26),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/gitlab_shell_secret",
             position: (70, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "log_file",
             position: (71, 5),
            },
           ],
          },
          String {
           parts: [
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (71, 19),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "statePath",
                 position: (71, 23),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/log/gitlab-shell.log",
             position: (71, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "redis",
             position: (72, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "bin",
                position: (73, 7),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (73, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "redis",
                    position: (73, 21),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/redis-cli",
                position: (73, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (74, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "127.0.0.1",
                position: (74, 15),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (75, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (75, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "services",
                 position: (75, 21),
                },
                Raw {
                 content: "redis",
                 position: (75, 30),
                },
                Raw {
                 content: "servers",
                 position: (75, 36),
                },
                Raw {
                 content: "gitlab",
                 position: (75, 44),
                },
                Raw {
                 content: "port",
                 position: (75, 51),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "database",
                position: (76, 7),
               },
              ],
             },
             Int {
              value: 0,
              position: (76, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "namespace",
                position: (77, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "resque:gitlab",
                position: (77, 20),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (72, 13),
          },
         ),
        ],
        recursive: false,
        position: (65, 65),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "redisConfig",
        position: (81, 3),
       },
       Raw {
        content: "production",
        position: (81, 15),
       },
       Raw {
        content: "url",
        position: (81, 26),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (81, 32),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "redisUrl",
         position: (81, 36),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pagesArgs",
        position: (83, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Concatenation,
      operands: [
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "-pages-domain",
            position: (84, 6),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "gitlabConfig",
           position: (84, 21),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "production",
             position: (84, 34),
            },
            Raw {
             content: "pages",
             position: (84, 45),
            },
            Raw {
             content: "host",
             position: (84, 51),
            },
           ],
          },
          default: None,
         },
         String {
          parts: [
           Raw {
            content: "-pages-root",
            position: (85, 6),
           },
          ],
         },
         String {
          parts: [
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "gitlabConfig",
              position: (85, 22),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "production",
                position: (85, 35),
               },
               Raw {
                content: "shared",
                position: (85, 46),
               },
               Raw {
                content: "path",
                position: (85, 53),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: "/pages",
            position: (85, 58),
           },
          ],
         },
        ],
        position: (83, 15),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (86, 8),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "pagesExtraArgs",
           position: (86, 12),
          },
         ],
        },
        default: None,
       },
      ],
      position: (86, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlabConfig",
        position: (88, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "production",
           position: (90, 5),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "flip",
          position: (90, 18),
         },
         arguments: [
          Variable {
           identifier: "recursiveUpdate",
           position: (90, 23),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (90, 39),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraConfig",
              position: (90, 43),
             },
            ],
           },
           default: None,
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gitlab",
                position: (91, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "host",
                   position: (92, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (92, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "host",
                    position: (92, 20),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "port",
                   position: (93, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (93, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "port",
                    position: (93, 20),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "https",
                   position: (94, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (94, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "https",
                    position: (94, 21),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "user",
                   position: (95, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (95, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (95, 20),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "email_enabled",
                   position: (96, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (96, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "email_display_name",
                   position: (97, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GitLab",
                   position: (97, 31),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "email_reply_to",
                   position: (98, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "noreply@localhost",
                   position: (98, 27),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default_theme",
                   position: (99, 9),
                  },
                 ],
                },
                Int {
                 value: 2,
                 position: (99, 25),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default_projects_features",
                   position: (100, 9),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "issues",
                      position: (101, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (101, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "merge_requests",
                      position: (102, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (102, 28),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wiki",
                      position: (103, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (103, 18),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "snippets",
                      position: (104, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (104, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "builds",
                      position: (105, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (105, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "container_registry",
                      position: (106, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (106, 32),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (100, 37),
                },
               ),
              ],
              recursive: false,
              position: (91, 16),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "repositories",
                position: (109, 7),
               },
               Raw {
                content: "storages",
                position: (109, 20),
               },
               Raw {
                content: "default",
                position: (109, 29),
               },
               Raw {
                content: "path",
                position: (109, 37),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (109, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (109, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/repositories",
                position: (109, 61),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "repositories",
                position: (110, 7),
               },
               Raw {
                content: "storages",
                position: (110, 20),
               },
               Raw {
                content: "default",
                position: (110, 29),
               },
               Raw {
                content: "gitaly_address",
                position: (110, 37),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "unix:",
                position: (110, 55),
               },
               Expression {
                expression: Variable {
                 identifier: "gitalySocket",
                 position: (110, 62),
                },
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "artifacts",
                position: (111, 7),
               },
               Raw {
                content: "enabled",
                position: (111, 17),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (111, 27),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "lfs",
                position: (112, 7),
               },
               Raw {
                content: "enabled",
                position: (112, 11),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (112, 21),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gravatar",
                position: (113, 7),
               },
               Raw {
                content: "enabled",
                position: (113, 16),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (113, 26),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "cron_jobs",
                position: (114, 7),
               },
              ],
             },
             Map {
              bindings: [],
              recursive: false,
              position: (114, 19),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gitlab_ci",
                position: (115, 7),
               },
               Raw {
                content: "builds_path",
                position: (115, 17),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (115, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (115, 38),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/builds",
                position: (115, 48),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "ldap",
                position: (116, 7),
               },
               Raw {
                content: "enabled",
                position: (116, 12),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (116, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "omniauth",
                position: (117, 7),
               },
               Raw {
                content: "enabled",
                position: (117, 16),
               },
              ],
             },
             Variable {
              identifier: "false",
              position: (117, 26),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "shared",
                position: (118, 7),
               },
               Raw {
                content: "path",
                position: (118, 14),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (118, 24),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (118, 28),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/shared",
                position: (118, 38),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gitaly",
                position: (119, 7),
               },
               Raw {
                content: "client_path",
                position: (119, 14),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (119, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "packages",
                    position: (119, 35),
                   },
                   Raw {
                    content: "gitaly",
                    position: (119, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin",
                position: (119, 51),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "backup",
                position: (120, 7),
               },
              ],
             },
             BinaryOperation {
              operator: Update,
              operands: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "gitaly_backup_path",
                     position: (121, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (121, 33),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "packages",
                         position: (121, 37),
                        },
                        Raw {
                         content: "gitaly",
                         position: (121, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/gitaly-backup",
                     position: (121, 53),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (122, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (122, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "backup",
                      position: (122, 20),
                     },
                     Raw {
                      content: "path",
                      position: (122, 27),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "keep_time",
                     position: (123, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (123, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "backup",
                      position: (123, 25),
                     },
                     Raw {
                      content: "keepTime",
                      position: (123, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                ],
                recursive: false,
                position: (120, 16),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optionalAttrs",
                 position: (124, 13),
                },
                arguments: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (124, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "backup",
                       position: (124, 32),
                      },
                      Raw {
                       content: "uploadOptions",
                       position: (124, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                   Map {
                    bindings: [],
                    recursive: false,
                    position: (124, 56),
                   },
                  ],
                  position: (124, 53),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "upload",
                       position: (125, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (125, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "backup",
                        position: (125, 22),
                       },
                       Raw {
                        content: "uploadOptions",
                        position: (125, 29),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (124, 60),
                 },
                ],
               },
              ],
              position: (124, 9),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gitlab_shell",
                position: (127, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (128, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (128, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "packages",
                       position: (128, 23),
                      },
                      Raw {
                       content: "gitlab-shell",
                       position: (128, 32),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "hooks_path",
                   position: (129, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (129, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "statePath",
                       position: (129, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/shell/hooks",
                   position: (129, 39),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "secret_file",
                   position: (130, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (130, 26),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "statePath",
                       position: (130, 30),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/gitlab_shell_secret",
                   position: (130, 40),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "upload_pack",
                   position: (131, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (131, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "receive_pack",
                   position: (132, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (132, 24),
                },
               ),
              ],
              recursive: false,
              position: (127, 22),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "workhorse",
                position: (134, 7),
               },
               Raw {
                content: "secret_file",
                position: (134, 17),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (134, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (134, 38),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/.gitlab_workhorse_secret",
                position: (134, 48),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gitlab_kas",
                position: (135, 7),
               },
               Raw {
                content: "secret_file",
                position: (135, 18),
               },
              ],
             },
             String {
              parts: [
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (135, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (135, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/.gitlab_kas_secret",
                position: (135, 49),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "git",
                position: (136, 7),
               },
               Raw {
                content: "bin_path",
                position: (136, 11),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "git",
                position: (136, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "monitoring",
                position: (137, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ip_whitelist",
                   position: (138, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "127.0.0.0/8",
                     position: (138, 27),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "::1/128",
                     position: (138, 41),
                    },
                   ],
                  },
                 ],
                 position: (138, 24),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "sidekiq_exporter",
                   position: (139, 9),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "enable",
                      position: (140, 11),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (140, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "address",
                      position: (141, 11),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "localhost",
                      position: (141, 22),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "port",
                      position: (142, 11),
                     },
                    ],
                   },
                   Int {
                    value: 3807,
                    position: (142, 18),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (139, 28),
                },
               ),
              ],
              recursive: false,
              position: (137, 20),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "registry",
                position: (145, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (145, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "optionalAttrs",
                  position: (145, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (145, 36),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "registry",
                   position: (145, 40),
                  },
                  Raw {
                   content: "enable",
                   position: (145, 49),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "enabled",
                     position: (146, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (146, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "host",
                     position: (147, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (147, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "registry",
                      position: (147, 20),
                     },
                     Raw {
                      content: "externalAddress",
                      position: (147, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "port",
                     position: (148, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (148, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "registry",
                      position: (148, 20),
                     },
                     Raw {
                      content: "externalPort",
                      position: (148, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "key",
                     position: (149, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (149, 15),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "registry",
                      position: (149, 19),
                     },
                     Raw {
                      content: "keyFile",
                      position: (149, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "api_url",
                     position: (150, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "http://",
                     position: (150, 20),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (150, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "services",
                         position: (150, 36),
                        },
                        Raw {
                         content: "dockerRegistry",
                         position: (150, 45),
                        },
                        Raw {
                         content: "listenAddress",
                         position: (150, 60),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: ":",
                     position: (150, 74),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (150, 77),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (150, 86),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "services",
                           position: (150, 93),
                          },
                          Raw {
                           content: "dockerRegistry",
                           position: (150, 102),
                          },
                          Raw {
                           content: "port",
                           position: (150, 117),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "/",
                     position: (150, 122),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "issuer",
                     position: (151, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-issuer",
                     position: (151, 19),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (145, 56),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extra",
                position: (153, 7),
               },
              ],
             },
             Map {
              bindings: [],
              recursive: false,
              position: (153, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "uploads",
                position: (154, 7),
               },
               Raw {
                content: "storage_path",
                position: (154, 15),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (154, 30),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "statePath",
                 position: (154, 34),
                },
               ],
              },
              default: None,
             },
            ),
           ],
           recursive: false,
           position: (90, 55),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (88, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlabEnv",
        position: (158, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Update,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (158, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "packages",
           position: (158, 19),
          },
          Raw {
           content: "gitlab",
           position: (158, 28),
          },
          Raw {
           content: "gitlabEnv",
           position: (158, 35),
          },
         ],
        },
        default: None,
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "HOME",
               position: (159, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (159, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (159, 19),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/home",
               position: (159, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "PUMA_PATH",
               position: (160, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (160, 20),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (160, 24),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/",
               position: (160, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "GITLAB_PATH",
               position: (161, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (161, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "packages",
                   position: (161, 26),
                  },
                  Raw {
                   content: "gitlab",
                   position: (161, 35),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/share/gitlab/",
               position: (161, 42),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "SCHEMA",
               position: (162, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (162, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (162, 21),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/db/structure.sql",
               position: (162, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "GITLAB_UPLOADS_PATH",
               position: (163, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (163, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (163, 34),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/uploads",
               position: (163, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "GITLAB_LOG_PATH",
               position: (164, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (164, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (164, 30),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/log",
               position: (164, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "GITLAB_REDIS_CONFIG_FILE",
               position: (165, 5),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (165, 32),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "writeText",
                 position: (165, 37),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "redis.yml",
                 position: (165, 48),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (165, 60),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toJSON",
                   position: (165, 69),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "redisConfig",
                 position: (165, 76),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "prometheus_multiproc_dir",
               position: (166, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "/run/gitlab",
               position: (166, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "RAILS_ENV",
               position: (167, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "production",
               position: (167, 18),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "MALLOC_ARENA_MAX",
               position: (168, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "2",
               position: (168, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (158, 48),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (169, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "extraEnv",
             position: (169, 12),
            },
           ],
          },
          default: None,
         },
        ],
        position: (169, 5),
       },
      ],
      position: (158, 45),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlab-rake",
        position: (171, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (171, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "stdenv",
          position: (171, 22),
         },
         Raw {
          content: "mkDerivation",
          position: (171, 29),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (172, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "gitlab-rake",
             position: (172, 13),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "buildInputs",
             position: (173, 5),
            },
           ],
          },
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (173, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "makeWrapper",
                position: (173, 26),
               },
              ],
             },
             default: None,
            },
           ],
           position: (173, 19),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "dontBuild",
             position: (174, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (174, 17),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "dontUnpack",
             position: (175, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (175, 18),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "installPhase",
             position: (176, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "mkdir -p $out/bin\nmakeWrapper ",
             position: (177, 1),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (178, 21),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (178, 25),
                },
                Raw {
                 content: "gitlab",
                 position: (178, 34),
                },
                Raw {
                 content: "rubyEnv",
                 position: (178, 41),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/bin/rake $out/bin/gitlab-rake \\\n    ",
             position: (178, 49),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "concatStrings",
               position: (179, 13),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (179, 28),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "name",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "value",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: String {
                    parts: [
                     Raw {
                      content: "--set ",
                      position: (179, 58),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (179, 66),
                      },
                     },
                     Raw {
                      content: " '",
                      position: (179, 71),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "value",
                       position: (179, 75),
                      },
                     },
                     Raw {
                      content: "' ",
                      position: (179, 81),
                     },
                    ],
                   },
                   position: (179, 50),
                  },
                  position: (179, 44),
                 },
                 Variable {
                  identifier: "gitlabEnv",
                  position: (179, 86),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " \\\n    --set PATH ",
             position: (179, 97),
            },
            Raw {
             content: "'",
             position: (180, 22),
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (180, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "makeBinPath",
                  position: (180, 29),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 43),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "nodejs",
                     position: (180, 48),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 55),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gzip",
                     position: (180, 60),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 65),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "git",
                     position: (180, 70),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 74),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gnutar",
                     position: (180, 79),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (180, 86),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 104),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "coreutils",
                     position: (180, 109),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (180, 119),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "procps",
                     position: (180, 124),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (180, 41),
               },
              ],
             },
            },
            Raw {
             content: ":$PATH' \\\n    --set RAKEOPT '-f ",
             position: (180, 133),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (181, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (181, 35),
                },
                Raw {
                 content: "gitlab",
                 position: (181, 44),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/share/gitlab/Rakefile' \\\n    --run 'cd ",
             position: (181, 51),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (182, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (182, 27),
                },
                Raw {
                 content: "gitlab",
                 position: (182, 36),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/share/gitlab'\n",
             position: (182, 43),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (171, 42),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gitlab-rails",
        position: (186, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (186, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "stdenv",
          position: (186, 23),
         },
         Raw {
          content: "mkDerivation",
          position: (186, 30),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (187, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "gitlab-rails",
             position: (187, 13),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "buildInputs",
             position: (188, 5),
            },
           ],
          },
          List {
           elements: [
            PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (188, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "makeWrapper",
                position: (188, 26),
               },
              ],
             },
             default: None,
            },
           ],
           position: (188, 19),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "dontBuild",
             position: (189, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (189, 17),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "dontUnpack",
             position: (190, 5),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (190, 18),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "installPhase",
             position: (191, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "mkdir -p $out/bin\nmakeWrapper ",
             position: (192, 1),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (193, 21),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (193, 25),
                },
                Raw {
                 content: "gitlab",
                 position: (193, 34),
                },
                Raw {
                 content: "rubyEnv",
                 position: (193, 41),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/bin/rails $out/bin/gitlab-rails \\\n    ",
             position: (193, 49),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "concatStrings",
               position: (194, 13),
              },
              arguments: [
               FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (194, 28),
                },
                arguments: [
                 Function {
                  argument: Some(
                   "name",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Function {
                   argument: Some(
                    "value",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: String {
                    parts: [
                     Raw {
                      content: "--set ",
                      position: (194, 58),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (194, 66),
                      },
                     },
                     Raw {
                      content: " '",
                      position: (194, 71),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "value",
                       position: (194, 75),
                      },
                     },
                     Raw {
                      content: "' ",
                      position: (194, 81),
                     },
                    ],
                   },
                   position: (194, 50),
                  },
                  position: (194, 44),
                 },
                 Variable {
                  identifier: "gitlabEnv",
                  position: (194, 86),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " \\\n    --set PATH ",
             position: (194, 97),
            },
            Raw {
             content: "'",
             position: (195, 22),
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (195, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "makeBinPath",
                  position: (195, 29),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 43),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "nodejs",
                     position: (195, 48),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 55),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gzip",
                     position: (195, 60),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 65),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "git",
                     position: (195, 70),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 74),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gnutar",
                     position: (195, 79),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (195, 86),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 104),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "coreutils",
                     position: (195, 109),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (195, 119),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "procps",
                     position: (195, 124),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (195, 41),
               },
              ],
             },
            },
            Raw {
             content: ":$PATH' \\\n    --run 'cd ",
             position: (195, 133),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (196, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (196, 27),
                },
                Raw {
                 content: "gitlab",
                 position: (196, 36),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/share/gitlab'\n",
             position: (196, 43),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (186, 43),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "extraGitlabRb",
        position: (200, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (200, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (200, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "extra-gitlab.rb",
          position: (200, 35),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (200, 52),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "extraGitlabRb",
           position: (200, 56),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "smtpSettings",
        position: (202, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (202, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (202, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "gitlab-smtp-settings.rb",
          position: (202, 34),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "if Rails.env.production?\n  Rails.application.config.action_mailer.delivery_method = :smtp\n\n  ActionMailer::Base.delivery_method = :smtp\n  ActionMailer::Base.smtp_settings = {\n    address: \"",
          position: (203, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (208, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (208, 25),
             },
             Raw {
              content: "address",
              position: (208, 30),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\",\n    port: ",
          position: (208, 38),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (209, 17),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (209, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "smtp",
                position: (209, 30),
               },
               Raw {
                content: "port",
                position: (209, 35),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ",\n    ",
          position: (209, 40),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (210, 11),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (210, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "smtp",
                  position: (210, 31),
                 },
                 Raw {
                  content: "username",
                  position: (210, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (210, 48),
              },
             ],
             position: (210, 45),
            },
            String {
             parts: [
              Raw {
               content: "user_name: \"",
               position: (210, 56),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (210, 70),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "smtp",
                   position: (210, 74),
                  },
                  Raw {
                   content: "username",
                   position: (210, 79),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\",",
               position: (210, 88),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n    ",
          position: (210, 93),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (211, 11),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (211, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "smtp",
                  position: (211, 31),
                 },
                 Raw {
                  content: "passwordFile",
                  position: (211, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (211, 52),
              },
             ],
             position: (211, 49),
            },
            String {
             parts: [
              Raw {
               content: "password: \"@smtpPassword@\",",
               position: (211, 60),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n    domain: \"",
          position: (211, 90),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (212, 20),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (212, 24),
             },
             Raw {
              content: "domain",
              position: (212, 29),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\",\n    ",
          position: (212, 36),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (213, 11),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (213, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "smtp",
                  position: (213, 31),
                 },
                 Raw {
                  content: "authentication",
                  position: (213, 36),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (213, 54),
              },
             ],
             position: (213, 51),
            },
            String {
             parts: [
              Raw {
               content: "authentication: :",
               position: (213, 61),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (213, 80),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "smtp",
                   position: (213, 84),
                  },
                  Raw {
                   content: "authentication",
                   position: (213, 89),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: ",",
               position: (213, 104),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n    enable_starttls_auto: ",
          position: (213, 107),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (214, 33),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (214, 46),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "smtp",
                position: (214, 50),
               },
               Raw {
                content: "enableStartTLSAuto",
                position: (214, 55),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ",\n    tls: ",
          position: (214, 74),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (215, 16),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (215, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "smtp",
                position: (215, 33),
               },
               Raw {
                content: "tls",
                position: (215, 38),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ",\n    ca_file: \"/etc/ssl/certs/ca-certificates.crt\",\n    openssl_verify_mode: ",
          position: (215, 42),
         },
         Raw {
          content: "'",
          position: (217, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (217, 33),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (217, 37),
             },
             Raw {
              content: "opensslVerifyMode",
              position: (217, 42),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "'\n  }\nend\n",
          position: (217, 60),
         },
        ],
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (224, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (225, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (225, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
               position: (225, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "stateDir",
               position: (225, 51),
              },
             ],
            },
           ],
           position: (225, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (225, 66),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
               position: (225, 77),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "statePath",
               position: (225, 86),
              },
             ],
            },
           ],
           position: (225, 63),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (226, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (226, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
               position: (226, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "backupPath",
               position: (226, 51),
              },
             ],
            },
           ],
           position: (226, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (226, 68),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
               position: (226, 79),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "backup",
               position: (226, 88),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "path",
               position: (226, 97),
              },
             ],
            },
           ],
           position: (226, 65),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (227, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (227, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
               position: (227, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "satelliteDir",
               position: (227, 51),
              },
             ],
            },
           ],
           position: (227, 28),
          },
          String {
           parts: [],
          },
         ],
        },
       ],
       position: (224, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (230, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (231, 5),
           },
           Raw {
            content: "gitlab",
            position: (231, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (232, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (232, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (233, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (233, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (233, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (234, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (234, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (235, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable the gitlab service.\n",
                    position: (236, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (232, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (240, 7),
              },
              Raw {
               content: "gitlab",
               position: (240, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (240, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (241, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (241, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (241, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (242, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (242, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitlab",
                     position: (242, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (243, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (243, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitlab",
                      position: (243, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (244, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab package",
                    position: (244, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (245, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (245, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitlab-ee",
                      position: (245, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (240, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (248, 7),
              },
              Raw {
               content: "gitlab-shell",
               position: (248, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (248, 31),
             },
             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: "package",
                     position: (249, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (250, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (250, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitlab-shell",
                     position: (250, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (251, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (251, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitlab-shell",
                      position: (251, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (252, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-shell package",
                    position: (252, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (248, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (255, 7),
              },
              Raw {
               content: "gitlab-workhorse",
               position: (255, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (255, 35),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (256, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (256, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (256, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (257, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (257, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitlab-workhorse",
                     position: (257, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (258, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (258, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitlab-workhorse",
                      position: (258, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (259, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-workhorse package",
                    position: (259, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (255, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (262, 7),
              },
              Raw {
               content: "gitaly",
               position: (262, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (262, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (263, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (263, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (263, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (264, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (264, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitaly",
                     position: (264, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (265, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (265, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitaly",
                      position: (265, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (266, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitaly package",
                    position: (266, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (262, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (269, 7),
              },
              Raw {
               content: "pages",
               position: (269, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (269, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (270, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (270, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (270, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (271, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (271, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gitlab-pages",
                     position: (271, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (272, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (272, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitlab-pages",
                      position: (272, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (273, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-pages package",
                    position: (273, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (269, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "statePath",
               position: (276, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (276, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (277, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (277, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (277, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (278, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/gitlab/state",
                    position: (278, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (279, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab state directory. Configuration, repositories and\nlogs, among other things, are stored here.\n\nThe directory will be created automatically if it doesn't\nexist already. Its parent directories must be owned by\neither <literal>root</literal> or the user set in\n<option>services.gitlab.user</option>.\n",
                    position: (280, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (276, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraEnv",
               position: (290, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (290, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (291, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (291, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (291, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (291, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (291, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (292, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (292, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (293, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Additional environment variables for the GitLab environment.\n",
                    position: (294, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (290, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "backup",
               position: (298, 7),
              },
              Raw {
               content: "startAt",
               position: (298, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (298, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (299, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (299, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (299, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (299, 35),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (299, 40),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (299, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (299, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (300, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (300, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (301, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "03:00",
                    position: (301, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (302, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The time(s) to run automatic backup of GitLab\nstate. Specified in systemd's time format; see\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry>.\n",
                    position: (303, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (298, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "backup",
               position: (310, 7),
              },
              Raw {
               content: "path",
               position: (310, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (310, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (311, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (311, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (311, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (312, 9),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (312, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "statePath",
                       position: (312, 23),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/backup",
                      position: (312, 36),
                     },
                    ],
                   },
                  ],
                  position: (312, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (313, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (313, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "config.",
                      position: (313, 43),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (313, 52),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (313, 56),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: " + \"/backup\"",
                      position: (313, 66),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (314, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab path for backups.",
                    position: (314, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (310, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "backup",
               position: (317, 7),
              },
              Raw {
               content: "keepTime",
               position: (317, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (317, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (318, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (318, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (318, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (319, 9),
                   },
                  ],
                 },
                 Int {
                  value: 0,
                  position: (319, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (320, 9),
                   },
                  ],
                 },
                 Int {
                  value: 48,
                  position: (320, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (321, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: Multiplication,
                   operands: [
                    BinaryOperation {
                     operator: Multiplication,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (321, 20),
                      },
                      Int {
                       value: 60,
                       position: (321, 24),
                      },
                     ],
                     position: (321, 22),
                    },
                    Int {
                     value: 60,
                     position: (321, 29),
                    },
                   ],
                   position: (321, 27),
                  },
                  position: (321, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (322, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How long to keep the backups around, in\nhours. <literal>0</literal> means <quote>keep\nforever</quote>.\n",
                    position: (323, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (317, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "backup",
               position: (329, 7),
              },
              Raw {
               content: "skip",
               position: (329, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (329, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (330, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (330, 21),
                  },
                  target: LetIn {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (331, 15),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "enum",
                       position: (331, 23),
                      },
                      arguments: [
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "db",
                            position: (332, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "uploads",
                            position: (333, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "builds",
                            position: (334, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "artifacts",
                            position: (335, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "lfs",
                            position: (336, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "registry",
                            position: (337, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "pages",
                            position: (338, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "repositories",
                            position: (339, 18),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "tar",
                            position: (340, 18),
                           },
                          ],
                         },
                        ],
                        position: (331, 28),
                       },
                      ],
                     },
                    ),
                   ],
                   target: FunctionApplication {
                    function: Variable {
                     identifier: "either",
                     position: (343, 13),
                    },
                    arguments: [
                     Variable {
                      identifier: "value",
                      position: (343, 20),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "listOf",
                       position: (343, 27),
                      },
                      arguments: [
                       Variable {
                        identifier: "value",
                        position: (343, 34),
                       },
                      ],
                     },
                    ],
                   },
                   position: (331, 11),
                  },
                  position: (330, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (344, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (344, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (345, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "artifacts",
                      position: (345, 22),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "lfs",
                      position: (345, 34),
                     },
                    ],
                   },
                  ],
                  position: (345, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (346, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "isString",
                     position: (346, 23),
                    },
                    arguments: [
                     Variable {
                      identifier: "x",
                      position: (346, 32),
                     },
                    ],
                   },
                   then: Variable {
                    identifier: "x",
                    position: (346, 39),
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (346, 46),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: ",",
                        position: (346, 64),
                       },
                      ],
                     },
                     Variable {
                      identifier: "x",
                      position: (346, 67),
                     },
                    ],
                   },
                   position: (346, 20),
                  },
                  position: (346, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (347, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Directories to exclude from the backup. The example excludes\nCI artifacts and LFS objects from the backups. The\n<literal>tar</literal> option skips the creation of a tar\nfile.\n\nRefer to <link xlink:href=\"https://docs.gitlab.com/ee/raketasks/backup_restore.html#excluding-specific-directories-from-the-backup\"/>\nfor more information.\n",
                    position: (348, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (329, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "backup",
               position: (358, 7),
              },
              Raw {
               content: "uploadOptions",
               position: (358, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (358, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (359, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (359, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (359, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (360, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (360, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (361, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (361, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  # Fog storage connection settings, see http://fog.io/storage/\n  connection = {\n    provider = \"AWS\";\n    region = \"eu-north-1\";\n    aws_access_key_id = \"AKIAXXXXXXXXXXXXXXXX\";\n    aws_secret_access_key = { _secret = config.deployment.keys.aws_access_key.path; };\n  };\n\n  # The remote 'directory' to store your backups in.\n  # For S3, this would be the bucket name.\n  remote_directory = \"my-gitlab-backups\";\n\n  # Use multipart uploads when file size reaches 100MB, see\n  # http://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html\n  multipart_chunk_size = 104857600;\n\n  # Turns on AWS Server-Side Encryption with Amazon S3-Managed Keys for backups, this is optional\n  encryption = \"AES256\";\n\n  # Specifies Amazon S3 storage class to use for backups, this is optional\n  storage_class = \"STANDARD\";\n};\n",
                      position: (362, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (386, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab automatic upload specification. Tells GitLab to\nupload the backup to a remote location when done.\n\nAttributes specified here are added under\n<literal>production -> backup -> upload</literal> in\n<filename>config/gitlab.yml</filename>.\n",
                    position: (387, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (358, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databaseHost",
               position: (396, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (396, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (397, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (397, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (397, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (398, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (399, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab database hostname. An empty string means <quote>use\nlocal unix socket connection</quote>.\n",
                    position: (400, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (396, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databasePasswordFile",
               position: (405, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (405, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (406, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (406, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (406, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (406, 35),
                    },
                   ],
                  },
                  position: (406, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (407, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (407, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (408, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "File containing the GitLab database user password.\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (409, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (405, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databaseCreateLocally",
               position: (416, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (416, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (417, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (417, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (417, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (418, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (418, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (419, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether a database should be automatically created on the\nlocal host. Set this to <literal>false</literal> if you plan\non provisioning a local database yourself. This has no effect\nif <option>services.gitlab.databaseHost</option> is customized.\n",
                    position: (420, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (416, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databaseName",
               position: (427, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (427, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (428, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (428, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (428, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (429, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitlab",
                    position: (429, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (430, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab database name.",
                    position: (430, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (427, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databaseUsername",
               position: (433, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (433, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (434, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (434, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (434, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (435, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitlab",
                    position: (435, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (436, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab database user.",
                    position: (436, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (433, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "databasePool",
               position: (439, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (439, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (440, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (440, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (440, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (441, 9),
                   },
                  ],
                 },
                 Int {
                  value: 5,
                  position: (441, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (442, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database connection pool size.",
                    position: (442, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (439, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraDatabaseConfig",
               position: (445, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (445, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (446, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (446, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (446, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (447, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (447, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (448, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration in config/database.yml.",
                    position: (448, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (445, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "redisUrl",
               position: (451, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (451, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (452, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (452, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (452, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (453, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "redis://localhost:",
                    position: (453, 20),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (453, 40),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (453, 49),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "services",
                          position: (453, 56),
                         },
                         Raw {
                          content: "redis",
                          position: (453, 65),
                         },
                         Raw {
                          content: "servers",
                          position: (453, 71),
                         },
                         Raw {
                          content: "gitlab",
                          position: (453, 79),
                         },
                         Raw {
                          content: "port",
                          position: (453, 86),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "/",
                    position: (453, 91),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (454, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (454, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "redis://localhost:",
                      position: (454, 43),
                     },
                     Raw {
                      content: "$",
                      position: (454, 61),
                     },
                     Raw {
                      content: "{toString config.services.redis.servers.gitlab.port}/",
                      position: (454, 64),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (455, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Redis URL for all GitLab services except gitlab-shell",
                    position: (455, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (451, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraGitlabRb",
               position: (458, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (458, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (459, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (459, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (459, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (460, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (461, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "if Rails.env.production?\n  Rails.application.config.action_mailer.delivery_method = :sendmail\n  ActionMailer::Base.delivery_method = :sendmail\n  ActionMailer::Base.sendmail_settings = {\n    location: \"/run/wrappers/bin/sendmail\",\n    arguments: \"-i -t\"\n  }\nend\n",
                    position: (462, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (471, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be placed in config/extra-gitlab.rb. This can\nbe used to add configuration not otherwise exposed through this module's\noptions.\n",
                    position: (472, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (458, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "host",
               position: (478, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (478, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (479, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (479, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (479, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (480, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (480, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "networking",
                     position: (480, 26),
                    },
                    Raw {
                     content: "hostName",
                     position: (480, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (481, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (481, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "config.networking.hostName",
                      position: (481, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (482, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab host name. Used e.g. for copy-paste URLs.",
                    position: (482, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (478, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (485, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (485, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (486, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (486, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "port",
                     position: (486, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (487, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8080,
                  position: (487, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (488, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab server port for copy-paste URLs, e.g. 80 or 443 if you're\nservice over https.\n",
                    position: (489, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (485, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "https",
               position: (494, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (494, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (495, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (495, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (495, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (496, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (496, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (497, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether gitlab prints URLs with https as scheme.",
                    position: (497, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (494, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (500, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (500, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (501, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (501, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (501, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (502, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitlab",
                    position: (502, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (503, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User to run gitlab and all related services.",
                    position: (503, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (500, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (506, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (506, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (507, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (507, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (507, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (508, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "gitlab",
                    position: (508, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (509, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group to run gitlab and all related services.",
                    position: (509, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (506, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "initialRootEmail",
               position: (512, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (512, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (513, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (513, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (513, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (514, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "admin@local.host",
                    position: (514, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (515, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Initial email address of the root account if this is a new install.\n",
                    position: (516, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (512, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "initialRootPasswordFile",
               position: (520, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (520, 33),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (521, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (521, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (521, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (521, 35),
                    },
                   ],
                  },
                  position: (521, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (522, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (522, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (523, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "File containing the initial password of the root account if\nthis is a new install.\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (524, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (520, 42),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "registry",
               position: (532, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (533, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (533, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (534, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (534, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (534, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (535, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (535, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (536, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enable GitLab container registry.",
                       position: (536, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (533, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "host",
                  position: (538, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (538, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (539, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (539, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (539, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (540, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (540, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (540, 28),
                       },
                       Raw {
                        content: "gitlab",
                        position: (540, 37),
                       },
                       Raw {
                        content: "host",
                        position: (540, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (541, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (541, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "config.services.gitlab.host",
                         position: (541, 44),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (542, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry host name.",
                       position: (542, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (538, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "port",
                  position: (544, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (544, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (545, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (545, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "int",
                        position: (545, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (546, 11),
                      },
                     ],
                    },
                    Int {
                     value: 4567,
                     position: (546, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (547, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry port.",
                       position: (547, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (544, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "certFile",
                  position: (549, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (549, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (550, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (550, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "path",
                        position: (550, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (551, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to GitLab container registry certificate.",
                       position: (551, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (549, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "keyFile",
                  position: (553, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (553, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (554, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (554, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "path",
                        position: (554, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (555, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to GitLab container registry certificate-key.",
                       position: (555, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (553, 28),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "defaultForProjects",
                  position: (557, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (557, 30),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (558, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (558, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (558, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (559, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (559, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "registry",
                        position: (559, 25),
                       },
                       Raw {
                        content: "enable",
                        position: (559, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (560, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (560, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "config.",
                         position: (560, 44),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "opt",
                           position: (560, 53),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "registry",
                             position: (560, 57),
                            },
                            Raw {
                             content: "enable",
                             position: (560, 66),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (561, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "If GitLab container registry should be enabled by default for projects.",
                       position: (561, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (557, 39),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "issuer",
                  position: (563, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (563, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (564, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (564, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (564, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (565, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitlab-issuer",
                       position: (565, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (566, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry issuer.",
                       position: (566, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (563, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceName",
                  position: (568, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (568, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (569, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (569, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (569, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (570, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "container_registry",
                       position: (570, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (571, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry service name.",
                       position: (571, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (568, 32),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "externalAddress",
                  position: (573, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (573, 27),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (574, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (574, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (574, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (575, 11),
                      },
                     ],
                    },
                    String {
                     parts: [],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (576, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "External address used to access registry from the internet",
                       position: (576, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (573, 36),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "externalPort",
                  position: (578, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (578, 24),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (579, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (579, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "int",
                        position: (579, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (580, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "External port used to access registry from the internet",
                       position: (580, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (578, 33),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (532, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "smtp",
               position: (584, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (585, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (585, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (586, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (586, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (586, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (587, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (587, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (588, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enable gitlab mail delivery over SMTP.",
                       position: (588, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (585, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "address",
                  position: (591, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (591, 19),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (592, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (592, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (592, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (593, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "localhost",
                       position: (593, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (594, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Address of the SMTP server for GitLab.",
                       position: (594, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (591, 28),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "port",
                  position: (597, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (597, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (598, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (598, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "int",
                        position: (598, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (599, 11),
                      },
                     ],
                    },
                    Int {
                     value: 25,
                     position: (599, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (600, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Port of the SMTP server for GitLab.",
                       position: (600, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (597, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "username",
                  position: (603, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (603, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (604, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (604, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "nullOr",
                       position: (604, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (604, 37),
                       },
                      ],
                     },
                     position: (604, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (605, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (605, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (606, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Username of the SMTP server for GitLab.",
                       position: (606, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (603, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "passwordFile",
                  position: (609, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (609, 24),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (610, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (610, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (610, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (610, 31),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "path",
                          position: (610, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (611, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (611, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (612, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "File containing the password of the SMTP server for GitLab.\n\nThis should be a string, not a nix path, since nix paths\nare copied into the world-readable nix store.\n",
                       position: (613, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (609, 33),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "domain",
                  position: (620, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (620, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (621, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (621, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (621, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (622, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "localhost",
                       position: (622, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (623, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "HELO domain to use for outgoing mail.",
                       position: (623, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (620, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "authentication",
                  position: (626, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (626, 26),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (627, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (627, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "nullOr",
                       position: (627, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (627, 37),
                       },
                      ],
                     },
                     position: (627, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (628, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (628, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (629, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Authentication type to use, see http://api.rubyonrails.org/classes/ActionMailer/Base.html",
                       position: (629, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (626, 35),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enableStartTLSAuto",
                  position: (632, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (632, 30),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (633, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (633, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (633, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (634, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (634, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (635, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to try to use StartTLS.",
                       position: (635, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (632, 39),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "tls",
                  position: (638, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (638, 15),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (639, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (639, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (639, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (640, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (640, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (641, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to use TLS wrapper-mode.",
                       position: (641, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (638, 24),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "opensslVerifyMode",
                  position: (644, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (644, 29),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (645, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (645, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (645, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (646, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "peer",
                       position: (646, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (647, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "How OpenSSL checks the certificate, see http://api.rubyonrails.org/classes/ActionMailer/Base.html",
                       position: (647, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (644, 38),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (584, 14),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pagesExtraArgs",
               position: (651, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (651, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (652, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (652, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (652, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (652, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (652, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (653, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "-listen-proxy",
                      position: (653, 22),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "127.0.0.1:8090",
                      position: (653, 38),
                     },
                    ],
                   },
                  ],
                  position: (653, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (654, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Arguments to pass to the gitlab-pages daemon",
                    position: (654, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (651, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secrets",
               position: (657, 7),
              },
              Raw {
               content: "secretFile",
               position: (657, 15),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (657, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (658, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (658, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (658, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (658, 35),
                    },
                   ],
                  },
                  position: (658, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (659, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (659, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (660, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A file containing the secret used to encrypt variables in\nthe DB. If you change or lose this key you will be unable to\naccess variables stored in database.\n\nMake sure the secret is at least 32 characters and all random,\nno regular words or you'll be exposed to dictionary attacks.\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (661, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (657, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secrets",
               position: (673, 7),
              },
              Raw {
               content: "dbFile",
               position: (673, 15),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (673, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (674, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (674, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (674, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (674, 35),
                    },
                   ],
                  },
                  position: (674, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (675, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (675, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (676, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A file containing the secret used to encrypt variables in\nthe DB. If you change or lose this key you will be unable to\naccess variables stored in database.\n\nMake sure the secret is at least 32 characters and all random,\nno regular words or you'll be exposed to dictionary attacks.\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (677, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (673, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secrets",
               position: (689, 7),
              },
              Raw {
               content: "otpFile",
               position: (689, 15),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (689, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (690, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (690, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (690, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (690, 35),
                    },
                   ],
                  },
                  position: (690, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (691, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (691, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (692, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A file containing the secret used to encrypt secrets for OTP\ntokens. If you change or lose this key, users which have 2FA\nenabled for login won't be able to login anymore.\n\nMake sure the secret is at least 32 characters and all random,\nno regular words or you'll be exposed to dictionary attacks.\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (693, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (689, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secrets",
               position: (705, 7),
              },
              Raw {
               content: "jwsFile",
               position: (705, 15),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (705, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (706, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (706, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (706, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (706, 35),
                    },
                   ],
                  },
                  position: (706, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (707, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (707, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (708, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A file containing the secret used to encrypt session\nkeys. If you change or lose this key, users will be\ndisconnected.\n\nMake sure the secret is an RSA private key in PEM format. You can\ngenerate one with\n\nopenssl genrsa 2048\n\nThis should be a string, not a nix path, since nix paths are\ncopied into the world-readable nix store.\n",
                    position: (709, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (705, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraShellConfig",
               position: (723, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (723, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (724, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (724, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (724, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (725, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (725, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (726, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to merge into shell-config.yml",
                    position: (726, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (723, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "puma",
               position: (729, 7),
              },
              Raw {
               content: "workers",
               position: (729, 12),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (729, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (730, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (730, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (730, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (731, 9),
                   },
                  ],
                 },
                 Int {
                  value: 2,
                  position: (731, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (732, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (732, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (732, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "x",
                     position: (732, 38),
                    },
                   ],
                  },
                  position: (732, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (733, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The number of worker processes Puma should spawn. This\ncontrols the amount of parallel Ruby code can be\nexecuted. GitLab recommends <quote>Number of CPU cores -\n1</quote>, but at least two.\n\n<note>\n  <para>\n    Each worker consumes quite a bit of memory, so\n    be careful when increasing this.\n  </para>\n</note>\n",
                    position: (734, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (729, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "puma",
               position: (748, 7),
              },
              Raw {
               content: "threadsMin",
               position: (748, 12),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (748, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (749, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (749, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (749, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (750, 9),
                   },
                  ],
                 },
                 Int {
                  value: 0,
                  position: (750, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (751, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (751, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (751, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "x",
                     position: (751, 38),
                    },
                   ],
                  },
                  position: (751, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (752, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The minimum number of threads Puma should use per\nworker.\n\n<note>\n  <para>\n    Each thread consumes memory and contributes to Global VM\n    Lock contention, so be careful when increasing this.\n  </para>\n</note>\n",
                    position: (753, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (748, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "puma",
               position: (765, 7),
              },
              Raw {
               content: "threadsMax",
               position: (765, 12),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (765, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (766, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (766, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (766, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (767, 9),
                   },
                  ],
                 },
                 Int {
                  value: 4,
                  position: (767, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (768, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (768, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (768, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "x",
                     position: (768, 38),
                    },
                   ],
                  },
                  position: (768, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (769, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The maximum number of threads Puma should use per\nworker. This limits how many threads Puma will automatically\nspawn in response to requests. In contrast to workers,\nthreads will never be able to run Ruby code in parallel, but\ngive higher IO parallelism.\n\n<note>\n  <para>\n    Each thread consumes memory and contributes to Global VM\n    Lock contention, so be careful when increasing this.\n  </para>\n</note>\n",
                    position: (770, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (765, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sidekiq",
               position: (785, 7),
              },
              Raw {
               content: "memoryKiller",
               position: (785, 15),
              },
              Raw {
               content: "enable",
               position: (785, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (785, 37),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (786, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (786, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (786, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (787, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (787, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (788, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether the Sidekiq MemoryKiller should be turned\non. MemoryKiller kills Sidekiq when its memory consumption\nexceeds a certain limit.\n\nSee <link xlink:href=\"https://docs.gitlab.com/ee/administration/operations/sidekiq_memory_killer.html\"/>\nfor details.\n",
                    position: (789, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (785, 46),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sidekiq",
               position: (798, 7),
              },
              Raw {
               content: "memoryKiller",
               position: (798, 15),
              },
              Raw {
               content: "maxMemory",
               position: (798, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (798, 40),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (799, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (799, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (799, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (800, 9),
                   },
                  ],
                 },
                 Int {
                  value: 2000,
                  position: (800, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (801, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (801, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (801, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    BinaryOperation {
                     operator: Multiplication,
                     operands: [
                      Variable {
                       identifier: "x",
                       position: (801, 39),
                      },
                      Int {
                       value: 1024,
                       position: (801, 43),
                      },
                     ],
                     position: (801, 41),
                    },
                   ],
                  },
                  position: (801, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (802, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The maximum amount of memory, in MiB, a Sidekiq worker is\nallowed to consume before being killed.\n",
                    position: (803, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (798, 49),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sidekiq",
               position: (808, 7),
              },
              Raw {
               content: "memoryKiller",
               position: (808, 15),
              },
              Raw {
               content: "graceTime",
               position: (808, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (808, 40),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (809, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (809, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (809, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (810, 9),
                   },
                  ],
                 },
                 Int {
                  value: 900,
                  position: (810, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (811, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (811, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (811, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "x",
                     position: (811, 38),
                    },
                   ],
                  },
                  position: (811, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (812, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The time MemoryKiller waits after noticing excessive memory\nconsumption before killing Sidekiq.\n",
                    position: (813, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (808, 49),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sidekiq",
               position: (818, 7),
              },
              Raw {
               content: "memoryKiller",
               position: (818, 15),
              },
              Raw {
               content: "shutdownWait",
               position: (818, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (818, 43),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (819, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (819, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (819, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (820, 9),
                   },
                  ],
                 },
                 Int {
                  value: 30,
                  position: (820, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (821, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (821, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toString",
                       position: (821, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "x",
                     position: (821, 38),
                    },
                   ],
                  },
                  position: (821, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (822, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The time allowed for all jobs to finish before Sidekiq is\nkilled forcefully.\n",
                    position: (823, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (818, 52),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "logrotate",
               position: (828, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (829, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (829, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (830, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (830, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (830, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (831, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (831, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (832, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Enable rotation of log files.\n",
                       position: (833, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (829, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "frequency",
                  position: (837, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (837, 21),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (838, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (838, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (838, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (839, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "daily",
                       position: (839, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (840, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "How often to rotate the logs.",
                       position: (840, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (837, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "keep",
                  position: (843, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (843, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (844, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (844, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "int",
                        position: (844, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (845, 11),
                      },
                     ],
                    },
                    Int {
                     value: 30,
                     position: (845, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (846, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "How many rotations to keep.",
                       position: (846, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (843, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "extraConfig",
                  position: (849, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (849, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (850, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (850, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "lines",
                        position: (850, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (851, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "copytruncate\ncompress\n",
                       position: (852, 1),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (855, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Extra logrotate config options for this path. Refer to\n<link xlink:href=\"https://linux.die.net/man/8/logrotate\"/> for details.\n",
                       position: (856, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (849, 32),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (828, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (862, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (862, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (863, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (863, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (863, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (864, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (864, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (865, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (865, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  gitlab = {\n    default_projects_features = {\n      builds = false;\n    };\n  };\n  omniauth = {\n    enabled = true;\n    auto_sign_in_with_provider = \"openid_connect\";\n    allow_single_sign_on = [\"openid_connect\"];\n    block_auto_created_users = false;\n    providers = [\n      {\n        name = \"openid_connect\";\n        label = \"OpenID Connect\";\n        args = {\n          name = \"openid_connect\";\n          scope = [\"openid\" \"profile\"];\n          response_type = \"code\";\n          issuer = \"https://keycloak.example.com/auth/realms/My%20Realm\";\n          discovery = true;\n          client_auth_method = \"query\";\n          uid_field = \"preferred_username\";\n          client_options = {\n            identifier = \"gitlab\";\n            secret = { _secret = \"/var/keys/gitlab_oidc_secret\"; };\n            redirect_uri = \"https://git.example.com/users/auth/openid_connect/callback\";\n          };\n        };\n      }\n    ];\n  };\n};\n",
                      position: (866, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (900, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra options to be added under\n<literal>production</literal> in\n<filename>config/gitlab.yml</filename>, as a nix attribute\nset.\n\nOptions containing secret data should be set to an attribute\nset containing the attribute <literal>_secret</literal> - a\nstring pointing to a file containing the value the option\nshould be set to. See the example to get a better picture of\nthis: in the resulting\n<filename>config/gitlab.yml</filename> file, the\n<literal>production.omniauth.providers[0].args.client_options.secret</literal>\nkey will be set to the contents of the\n<filename>/var/keys/gitlab_oidc_secret</filename> file.\n",
                    position: (901, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (862, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (231, 23),
         },
        ),
       ],
       recursive: false,
       position: (230, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (920, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (920, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (920, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (920, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (922, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (924, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  Variable {
                   identifier: "databaseActuallyCreateLocally",
                   position: (924, 21),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (924, 55),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (924, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (924, 67),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (924, 71),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (924, 64),
                  },
                 ],
                 position: (924, 51),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (925, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "For local automatic database provisioning (services.gitlab.databaseCreateLocally == true) with peer authentication (services.gitlab.databaseHost == \"\") to work services.gitlab.user and services.gitlab.databaseUsername must be identical.",
                   position: (925, 21),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (923, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (928, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (928, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (928, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                    },
                   ],
                   position: (928, 39),
                  },
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (928, 50),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databasePasswordFile",
                        position: (928, 54),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (928, 78),
                    },
                   ],
                   position: (928, 75),
                  },
                 ],
                 position: (928, 46),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (929, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "When services.gitlab.databaseHost is customized, services.gitlab.databasePasswordFile must be set!",
                   position: (929, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (927, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (932, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (932, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "initialRootPasswordFile",
                      position: (932, 25),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (932, 52),
                  },
                 ],
                 position: (932, 49),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (933, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.initialRootPasswordFile must be set!",
                   position: (933, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (931, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (936, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (936, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (936, 25),
                     },
                     Raw {
                      content: "secretFile",
                      position: (936, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (936, 47),
                  },
                 ],
                 position: (936, 44),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (937, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.secretFile must be set!",
                   position: (937, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (935, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (940, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (940, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (940, 25),
                     },
                     Raw {
                      content: "dbFile",
                      position: (940, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (940, 43),
                  },
                 ],
                 position: (940, 40),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (941, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.dbFile must be set!",
                   position: (941, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (939, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (944, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (944, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (944, 25),
                     },
                     Raw {
                      content: "otpFile",
                      position: (944, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (944, 44),
                  },
                 ],
                 position: (944, 41),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (945, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.otpFile must be set!",
                   position: (945, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (943, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (948, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (948, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (948, 25),
                     },
                     Raw {
                      content: "jwsFile",
                      position: (948, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (948, 44),
                  },
                 ],
                 position: (948, 41),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (949, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.jwsFile must be set!",
                   position: (949, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (947, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (952, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "versionAtLeast",
                  position: (952, 21),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "postgresqlPackage",
                    position: (952, 36),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (952, 54),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "12.0.0",
                     position: (952, 63),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (953, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "PostgreSQL >=12 is required to run GitLab 14. Follow the instructions in the manual section for upgrading PostgreSQL here: https://nixos.org/manual/nixos/stable/index.html#module-services-postgres-upgrading",
                   position: (953, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (951, 7),
             },
            ],
            position: (922, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (957, 5),
             },
             Raw {
              content: "systemPackages",
              position: (957, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (957, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "git",
                 position: (957, 41),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "gitlab-rake",
              position: (957, 45),
             },
             Variable {
              identifier: "gitlab-rails",
              position: (957, 57),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (957, 70),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (957, 74),
                },
                Raw {
                 content: "gitlab-shell",
                 position: (957, 83),
                },
               ],
              },
              default: None,
             },
            ],
            position: (957, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (959, 5),
             },
             Raw {
              content: "targets",
              position: (959, 13),
             },
             Raw {
              content: "gitlab",
              position: (959, 21),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (960, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Common target for all GitLab services.",
                 position: (960, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (961, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (961, 21),
                  },
                 ],
                },
               ],
               position: (961, 18),
              },
             ),
            ],
            recursive: false,
            position: (959, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (965, 5),
             },
             Raw {
              content: "redis",
              position: (965, 14),
             },
             Raw {
              content: "servers",
              position: (965, 20),
             },
             Raw {
              content: "gitlab",
              position: (965, 28),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (966, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (966, 16),
               },
               arguments: [
                Variable {
                 identifier: "true",
                 position: (966, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (967, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (967, 14),
               },
               arguments: [
                Int {
                 value: 31636,
                 position: (967, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bind",
                 position: (968, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (968, 14),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "127.0.0.1",
                   position: (968, 25),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (965, 37),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (972, 5),
             },
             Raw {
              content: "postgresql",
              position: (972, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (972, 27),
            },
            arguments: [
             Variable {
              identifier: "databaseActuallyCreateLocally",
              position: (972, 41),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (973, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (973, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (974, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "singleton",
                  position: (974, 21),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (974, 33),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (974, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "databaseUsername",
                         position: (974, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (974, 31),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (972, 71),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (978, 5),
             },
             Raw {
              content: "logrotate",
              position: (978, 14),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (979, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (979, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "logrotate",
                  position: (979, 20),
                 },
                 Raw {
                  content: "enable",
                  position: (979, 30),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "paths",
                 position: (980, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "gitlab",
                    position: (981, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (982, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (982, 21),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (982, 25),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/log/*.log",
                       position: (982, 35),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (983, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (983, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (983, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (984, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (984, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "group",
                        position: (984, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "frequency",
                       position: (985, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (985, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (985, 27),
                       },
                       Raw {
                        content: "frequency",
                        position: (985, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "keep",
                       position: (986, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (986, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (986, 22),
                       },
                       Raw {
                        content: "keep",
                        position: (986, 32),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "extraConfig",
                       position: (987, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (987, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (987, 29),
                       },
                       Raw {
                        content: "extraConfig",
                        position: (987, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (981, 18),
                 },
                ),
               ],
               recursive: false,
               position: (980, 15),
              },
             ),
            ],
            recursive: false,
            position: (978, 26),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (995, 5),
             },
             Raw {
              content: "services",
              position: (995, 13),
             },
             Raw {
              content: "gitlab-postgresql",
              position: (995, 22),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "pgsql",
                 position: (995, 46),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (995, 54),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (995, 61),
                 },
                 Raw {
                  content: "postgresql",
                  position: (995, 70),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            target: FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (995, 85),
             },
             arguments: [
              Variable {
               identifier: "databaseActuallyCreateLocally",
               position: (995, 90),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (996, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "postgresql.service",
                      position: (996, 18),
                     },
                    ],
                   },
                  ],
                  position: (996, 15),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "bindsTo",
                    position: (997, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "postgresql.service",
                      position: (997, 20),
                     },
                    ],
                   },
                  ],
                  position: (997, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (998, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab.target",
                      position: (998, 21),
                     },
                    ],
                   },
                  ],
                  position: (998, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "partOf",
                    position: (999, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab.target",
                      position: (999, 19),
                     },
                    ],
                   },
                  ],
                  position: (999, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (1000, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "pgsql",
                     position: (1001, 9),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (1001, 15),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (1002, 9),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "util-linux",
                       position: (1002, 14),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                  position: (1000, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "script",
                    position: (1004, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "set -eu\n\nPSQL() {\n    psql --port=",
                    position: (1005, 1),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (1008, 27),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "pgsql",
                        position: (1008, 36),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "port",
                          position: (1008, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " \"$@\"\n}\n\nPSQL -tAc \"SELECT 1 FROM pg_database WHERE datname = ",
                    position: (1008, 47),
                   },
                   Raw {
                    content: "'",
                    position: (1011, 62),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1011, 65),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1011, 69),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "'\" | grep -q 1 || PSQL -tAc 'CREATE DATABASE \"",
                    position: (1011, 82),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1011, 130),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1011, 134),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" OWNER \"",
                    position: (1011, 147),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1011, 158),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1011, 162),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"'\ncurrent_owner=$(PSQL -tAc \"SELECT pg_catalog.pg_get_userbyid(datdba) FROM pg_catalog.pg_database WHERE datname = ",
                    position: (1011, 179),
                   },
                   Raw {
                    content: "'",
                    position: (1012, 122),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1012, 125),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1012, 129),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "'\")\nif [[ \"$current_owner\" != \"",
                    position: (1012, 142),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1013, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1013, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" ]]; then\n    PSQL -tAc 'ALTER DATABASE \"",
                    position: (1013, 59),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1014, 42),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1014, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" OWNER TO \"",
                    position: (1014, 59),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1014, 73),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1014, 77),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"'\n    if [[ -e \"",
                    position: (1014, 94),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1015, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1015, 32),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1015, 41),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1015, 52),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                    position: (1015, 60),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1015, 76),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1015, 80),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" ]]; then\n        echo \"Reassigning ownership of database ",
                    position: (1015, 93),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1016, 59),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1016, 63),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: " to user ",
                    position: (1016, 76),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1016, 87),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1016, 91),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: " failed on last boot. Failing...\"\n        exit 1\n    fi\n    touch \"",
                    position: (1016, 108),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1019, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1019, 29),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1019, 38),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1019, 49),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                    position: (1019, 57),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1019, 73),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1019, 77),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"\n    PSQL \"",
                    position: (1019, 90),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1020, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1020, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" -tAc \"REASSIGN OWNED BY \\\"$current_owner\\\" TO \\\"",
                    position: (1020, 38),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1020, 90),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1020, 94),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\\\"\"\n    rm \"",
                    position: (1020, 111),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1021, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1021, 26),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1021, 35),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1021, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                    position: (1021, 54),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1021, 70),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1021, 74),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"\nfi\nPSQL ",
                    position: (1021, 87),
                   },
                   Raw {
                    content: "'",
                    position: (1023, 14),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1023, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1023, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "' -tAc \"CREATE EXTENSION IF NOT EXISTS pg_trgm\"\nPSQL ",
                    position: (1023, 34),
                   },
                   Raw {
                    content: "'",
                    position: (1024, 14),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1024, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1024, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "' -tAc \"CREATE EXTENSION IF NOT EXISTS btree_gist;\"\n",
                    position: (1024, 34),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1027, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "User",
                       position: (1028, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pgsql",
                      position: (1028, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "superUser",
                        position: (1028, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Type",
                       position: (1029, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "oneshot",
                       position: (1029, 17),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RemainAfterExit",
                       position: (1030, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (1030, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1027, 23),
                 },
                ),
               ],
               recursive: false,
               position: (995, 120),
              },
             ],
            },
            position: (995, 42),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1034, 5),
             },
             Raw {
              content: "services",
              position: (1034, 13),
             },
             Raw {
              content: "gitlab-registry-cert",
              position: (1034, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1034, 45),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1034, 59),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1034, 63),
                },
                Raw {
                 content: "enable",
                 position: (1034, 72),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1035, 7),
                  },
                 ],
                },
                With {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (1035, 19),
                 },
                 target: List {
                  elements: [
                   Variable {
                    identifier: "openssl",
                    position: (1035, 27),
                   },
                  ],
                  position: (1035, 25),
                 },
                 position: (1035, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "script",
                   position: (1037, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mkdir -p $(dirname ",
                   position: (1038, 1),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1038, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1038, 34),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1038, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nmkdir -p $(dirname ",
                   position: (1038, 51),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1039, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1039, 34),
                      },
                      Raw {
                       content: "certFile",
                       position: (1039, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nopenssl req -nodes -newkey rsa:4096 -keyout ",
                   position: (1039, 52),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1040, 55),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1040, 59),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1040, 68),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -out /tmp/registry-auth.csr -subj \"/CN=",
                   position: (1040, 76),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1040, 118),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1040, 122),
                      },
                      Raw {
                       content: "issuer",
                       position: (1040, 131),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\"\nopenssl x509 -in /tmp/registry-auth.csr -out ",
                   position: (1040, 138),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1041, 56),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1041, 60),
                      },
                      Raw {
                       content: "certFile",
                       position: (1041, 69),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -req -signkey ",
                   position: (1041, 78),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1041, 95),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1041, 99),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1041, 108),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -days 3650\nchown ",
                   position: (1041, 116),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1042, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                   position: (1042, 26),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1042, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " $(dirname ",
                   position: (1042, 39),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 52),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1042, 56),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1042, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nchown ",
                   position: (1042, 73),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1043, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                   position: (1043, 26),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1043, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " $(dirname ",
                   position: (1043, 39),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 52),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1043, 56),
                      },
                      Raw {
                       content: "certFile",
                       position: (1043, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nchown ",
                   position: (1043, 74),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1044, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1044, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                   position: (1044, 26),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1044, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1044, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " ",
                   position: (1044, 39),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1044, 42),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1044, 46),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1044, 55),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\nchown ",
                   position: (1044, 63),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1045, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1045, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                   position: (1045, 26),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1045, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1045, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " ",
                   position: (1045, 39),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1045, 42),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1045, 46),
                      },
                      Raw {
                       content: "certFile",
                       position: (1045, 55),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n",
                   position: (1045, 64),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1048, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ConditionPathExists",
                      position: (1049, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "!",
                      position: (1049, 32),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1049, 35),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1049, 39),
                         },
                         Raw {
                          content: "certFile",
                          position: (1049, 48),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1048, 23),
                },
               ),
              ],
              recursive: false,
              position: (1034, 79),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1054, 5),
             },
             Raw {
              content: "services",
              position: (1054, 13),
             },
             Raw {
              content: "docker-registry",
              position: (1054, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1054, 40),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1054, 54),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1054, 58),
                },
                Raw {
                 content: "enable",
                 position: (1054, 67),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wants",
                   position: (1055, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-registry-cert.service",
                     position: (1055, 18),
                    },
                   ],
                  },
                 ],
                 position: (1055, 15),
                },
               ),
              ],
              recursive: false,
              position: (1054, 74),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (1059, 5),
             },
             Raw {
              content: "dockerRegistry",
              position: (1059, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1059, 31),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1059, 45),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1059, 49),
                },
                Raw {
                 content: "enable",
                 position: (1059, 58),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (1060, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (1060, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enableDelete",
                   position: (1061, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (1061, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "extraConfig",
                   position: (1062, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "auth",
                      position: (1063, 9),
                     },
                     Raw {
                      content: "token",
                      position: (1063, 14),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "realm",
                         position: (1064, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "http",
                         position: (1064, 20),
                        },
                        Expression {
                         expression: IfThenElse {
                          predicate: BinaryOperation {
                           operator: EqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (1064, 29),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "https",
                                position: (1064, 33),
                               },
                              ],
                             },
                             default: None,
                            },
                            Variable {
                             identifier: "true",
                             position: (1064, 42),
                            },
                           ],
                           position: (1064, 39),
                          },
                          then: String {
                           parts: [
                            Raw {
                             content: "s",
                             position: (1064, 53),
                            },
                           ],
                          },
                          else_: String {
                           parts: [],
                          },
                          position: (1064, 26),
                         },
                        },
                        Raw {
                         content: "://",
                         position: (1064, 64),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1064, 69),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "host",
                             position: (1064, 73),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/jwt/auth",
                         position: (1064, 78),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "service",
                         position: (1065, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1065, 21),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1065, 25),
                         },
                         Raw {
                          content: "serviceName",
                          position: (1065, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "issuer",
                         position: (1066, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1066, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1066, 24),
                         },
                         Raw {
                          content: "issuer",
                          position: (1066, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "rootcertbundle",
                         position: (1067, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1067, 28),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1067, 32),
                         },
                         Raw {
                          content: "certFile",
                          position: (1067, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    recursive: false,
                    position: (1063, 22),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1062, 21),
                },
               ),
              ],
              recursive: false,
              position: (1059, 65),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (1073, 5),
             },
             Raw {
              content: "postfix",
              position: (1073, 14),
             },
             Raw {
              content: "enable",
              position: (1073, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (1073, 31),
            },
            arguments: [
             BinaryOperation {
              operator: LogicalAnd,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (1073, 42),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "smtp",
                   position: (1073, 46),
                  },
                  Raw {
                   content: "enable",
                   position: (1073, 51),
                  },
                 ],
                },
                default: None,
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1073, 61),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "smtp",
                     position: (1073, 65),
                    },
                    Raw {
                     content: "address",
                     position: (1073, 70),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (1073, 82),
                   },
                  ],
                 },
                ],
                position: (1073, 78),
               },
              ],
              position: (1073, 58),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (1075, 5),
             },
             Raw {
              content: "users",
              position: (1075, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1075, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "user",
                  position: (1075, 23),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (1076, 9),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1076, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1076, 21),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (1077, 9),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1077, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "statePath",
                     position: (1077, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/home",
                 position: (1077, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "shell",
                 position: (1078, 9),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1078, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bash",
                     position: (1078, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/bash",
                 position: (1078, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (1079, 9),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (1079, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (1079, 22),
                 },
                 Raw {
                  content: "uids",
                  position: (1079, 26),
                 },
                 Raw {
                  content: "gitlab",
                  position: (1079, 31),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (1076, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (1082, 5),
             },
             Raw {
              content: "groups",
              position: (1082, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1082, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1082, 24),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "gid",
              position: (1082, 31),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1082, 37),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (1082, 44),
              },
              Raw {
               content: "gids",
               position: (1082, 48),
              },
              Raw {
               content: "gitlab",
               position: (1082, 53),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1084, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (1084, 13),
             },
             Raw {
              content: "rules",
              position: (1084, 22),
             },
            ],
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "d /run/gitlab 0755 ",
                position: (1085, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1085, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1085, 33),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1085, 38),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1085, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1085, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1085, 51),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1086, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabEnv",
                  position: (1086, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "HOME",
                    position: (1086, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
                position: (1086, 27),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1086, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1086, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1086, 44),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1086, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1086, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1086, 57),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "z ",
                position: (1087, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabEnv",
                  position: (1087, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "HOME",
                    position: (1087, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/.ssh/authorized_keys 0600 ",
                position: (1087, 27),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1087, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1087, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1087, 65),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1087, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1087, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1087, 78),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1088, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "backup",
                    position: (1088, 16),
                   },
                   Raw {
                    content: "path",
                    position: (1088, 23),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
                position: (1088, 28),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 36),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1088, 40),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1088, 45),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 48),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1088, 52),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1088, 58),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1089, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1089, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
                position: (1089, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1089, 38),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1089, 43),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1089, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1089, 56),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1090, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1090, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/builds 0750 ",
                position: (1090, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1090, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1090, 50),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 53),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1090, 57),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1090, 63),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1091, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1091, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/config 0750 ",
                position: (1091, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1091, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1091, 50),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 53),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1091, 57),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1091, 63),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1092, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1092, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/db 0750 ",
                position: (1092, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1092, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1092, 46),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 49),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1092, 53),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1092, 59),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1093, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1093, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log 0750 ",
                position: (1093, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1093, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1093, 47),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 50),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1093, 54),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1093, 60),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1094, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1094, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/repositories 2770 ",
                position: (1094, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1094, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1094, 56),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 59),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1094, 63),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1094, 69),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1095, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1095, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/shell 0750 ",
                position: (1095, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1095, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1095, 49),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 52),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1095, 56),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1095, 62),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1096, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1096, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1096, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp 0750 ",
                position: (1096, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1096, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1096, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1096, 47),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1096, 50),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1096, 54),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1096, 60),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1097, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1097, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp/pids 0750 ",
                position: (1097, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 43),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1097, 47),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1097, 52),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 55),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1097, 59),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1097, 65),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1098, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1098, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp/sockets 0750 ",
                position: (1098, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1098, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1098, 55),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 58),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1098, 62),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1098, 68),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1099, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1099, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/uploads 0700 ",
                position: (1099, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 42),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1099, 46),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1099, 51),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 54),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1099, 58),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1099, 64),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1100, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1100, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1100, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks 0700 ",
                position: (1100, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1100, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1100, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1100, 56),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1100, 59),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1100, 63),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1100, 69),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1101, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1101, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1101, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks/pre-receive.d 0700 ",
                position: (1101, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1101, 61),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1101, 65),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1101, 70),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1101, 73),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1101, 77),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1101, 83),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1102, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1102, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1102, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks/post-receive.d 0700 ",
                position: (1102, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1102, 62),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1102, 66),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1102, 71),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1102, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1102, 78),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1102, 84),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1103, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1103, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1103, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks/update.d 0700 ",
                position: (1103, 26),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1103, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1103, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1103, 65),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1103, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1103, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1103, 78),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1104, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1104, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1104, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1104, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1104, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
                position: (1104, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1104, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1104, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1104, 65),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1104, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1104, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1104, 78),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1105, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1105, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1105, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1105, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1105, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/artifacts 0750 ",
                position: (1105, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1105, 66),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1105, 70),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1105, 75),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1105, 78),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1105, 82),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1105, 88),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1106, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1106, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1106, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1106, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1106, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/lfs-objects 0750 ",
                position: (1106, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1106, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1106, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1106, 77),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1106, 80),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1106, 84),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1106, 90),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1107, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1107, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1107, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1107, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1107, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/packages 0750 ",
                position: (1107, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1107, 65),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1107, 69),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1107, 74),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1107, 77),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1107, 81),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1107, 87),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1108, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1108, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1108, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1108, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1108, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/pages 0750 ",
                position: (1108, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1108, 62),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1108, 66),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1108, 71),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1108, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1108, 78),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1108, 84),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "d ",
                position: (1109, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1109, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1109, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1109, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1109, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/terraform_state 0750 ",
                position: (1109, 48),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1109, 72),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1109, 76),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
                position: (1109, 81),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1109, 84),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1109, 88),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
                position: (1109, 94),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/config - - - - ",
                position: (1110, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1110, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1110, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/config",
                position: (1110, 54),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/log - - - - ",
                position: (1111, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1111, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1111, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log",
                position: (1111, 51),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/tmp - - - - ",
                position: (1112, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1112, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1112, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp",
                position: (1112, 51),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/uploads - - - - ",
                position: (1113, 8),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1113, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1113, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/uploads",
                position: (1113, 55),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/shell-config.yml - - - - ",
                position: (1115, 8),
               },
               Expression {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1115, 50),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "writeText",
                     position: (1115, 55),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "config.yml",
                     position: (1115, 66),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (1115, 79),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toJSON",
                       position: (1115, 88),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "gitlabShellConfig",
                     position: (1115, 95),
                    },
                   ],
                  },
                 ],
                },
               },
              ],
             },
            ],
            position: (1084, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1119, 5),
             },
             Raw {
              content: "services",
              position: (1119, 13),
             },
             Raw {
              content: "gitlab-config",
              position: (1119, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1120, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1120, 21),
                  },
                 ],
                },
               ],
               position: (1120, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1121, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1121, 19),
                  },
                 ],
                },
               ],
               position: (1121, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1122, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1122, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "jq",
                  position: (1123, 9),
                 },
                 Variable {
                  identifier: "openssl",
                  position: (1124, 9),
                 },
                 Variable {
                  identifier: "replace-secret",
                  position: (1125, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1126, 9),
                 },
                ],
                position: (1122, 25),
               },
               position: (1122, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1128, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1129, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "oneshot",
                    position: (1129, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1130, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1130, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1130, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1131, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1131, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1131, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1132, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1132, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1133, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (1133, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1134, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1134, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1134, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1134, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                    position: (1134, 51),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemainAfterExit",
                    position: (1135, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (1135, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStartPre",
                    position: (1137, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "preStartFullPrivileges",
                       position: (1138, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "set -o errexit -o pipefail -o nounset\nshopt -s dotglob nullglob inherit_errexit\n\nchown --no-dereference ",
                       position: (1139, 1),
                      },
                      Raw {
                       content: "'",
                       position: (1142, 36),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (1142, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "':",
                       position: (1142, 48),
                      },
                      Raw {
                       content: "'",
                       position: (1142, 50),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 53),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (1142, 57),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "' ",
                       position: (1142, 63),
                      },
                      Raw {
                       content: "'",
                       position: (1142, 65),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 68),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1142, 72),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/*\nif [[ -n \"$(ls -A ",
                       position: (1142, 82),
                      },
                      Raw {
                       content: "'",
                       position: (1143, 31),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1143, 34),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1143, 38),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/config/)\" ]]; then\n  chown --no-dereference ",
                       position: (1143, 48),
                      },
                      Raw {
                       content: "'",
                       position: (1144, 38),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1144, 41),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (1144, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "':",
                       position: (1144, 50),
                      },
                      Raw {
                       content: "'",
                       position: (1144, 52),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1144, 55),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (1144, 59),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "' ",
                       position: (1144, 65),
                      },
                      Raw {
                       content: "'",
                       position: (1144, 67),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1144, 70),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1144, 74),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/config/*\nfi\n",
                       position: (1144, 84),
                      },
                     ],
                    },
                   ),
                  ],
                  target: String {
                   parts: [
                    Raw {
                     content: "+",
                     position: (1147, 13),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (1147, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeShellScript",
                          position: (1147, 21),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "gitlab-pre-start-full-privileges",
                          position: (1147, 39),
                         },
                        ],
                       },
                       Variable {
                        identifier: "preStartFullPrivileges",
                        position: (1147, 73),
                       },
                      ],
                     },
                    },
                   ],
                  },
                  position: (1137, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1149, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1149, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "writeShellScript",
                      position: (1149, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab-config",
                      position: (1149, 44),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "set -o errexit -o pipefail -o nounset\nshopt -s inherit_errexit\n\numask u=rwx,g=rx,o=\n\ncp -f ",
                      position: (1150, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1155, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1155, 23),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1155, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/VERSION ",
                      position: (1155, 39),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1155, 63),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1155, 67),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/VERSION\nrm -rf ",
                      position: (1155, 77),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1156, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1156, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/db/*\nrm -f ",
                      position: (1156, 34),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1157, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1157, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/lib\nfind ",
                      position: (1157, 33),
                     },
                     Raw {
                      content: "'",
                      position: (1158, 16),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1158, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1158, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/' -maxdepth 1 -mindepth 1 -type d -execdir rm -rf {} \\;\ncp -rf --no-preserve=mode ",
                      position: (1158, 33),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1159, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1159, 43),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1159, 52),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/config.dist/* ",
                      position: (1159, 59),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1159, 89),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1159, 93),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config\ncp -rf --no-preserve=mode ",
                      position: (1159, 103),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1160, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1160, 43),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1160, 52),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/db/* ",
                      position: (1160, 59),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1160, 80),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1160, 84),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/db\nln -sf ",
                      position: (1160, 94),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "extraGitlabRb",
                       position: (1161, 20),
                      },
                     },
                     Raw {
                      content: " ",
                      position: (1161, 34),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1161, 37),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1161, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/initializers/extra-gitlab.rb\n\n",
                      position: (1161, 51),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1163, 13),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1163, 17),
                         },
                         Raw {
                          content: "gitlab-shell",
                          position: (1163, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/install\n\n",
                      position: (1163, 39),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (1165, 13),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1165, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "smtp",
                            position: (1165, 32),
                           },
                           Raw {
                            content: "enable",
                            position: (1165, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "install -m u=rw ",
                           position: (1166, 1),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "smtpSettings",
                            position: (1166, 33),
                           },
                          },
                          Raw {
                           content: " ",
                           position: (1166, 46),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1166, 49),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "statePath",
                               position: (1166, 53),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/config/initializers/smtp_settings.rb\n",
                           position: (1166, 63),
                          },
                          Expression {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "optionalString",
                             position: (1167, 17),
                            },
                            arguments: [
                             BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (1167, 33),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "smtp",
                                   position: (1167, 37),
                                  },
                                  Raw {
                                   content: "passwordFile",
                                   position: (1167, 42),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               Variable {
                                identifier: "null",
                                position: (1167, 58),
                               },
                              ],
                              position: (1167, 55),
                             },
                             String {
                              parts: [
                               Raw {
                                content: "replace-secret '@smtpPassword@' ",
                                position: (1168, 1),
                               },
                               Raw {
                                content: "'",
                                position: (1168, 51),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1168, 54),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "smtp",
                                    position: (1168, 58),
                                   },
                                   Raw {
                                    content: "passwordFile",
                                    position: (1168, 63),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "' ",
                                position: (1168, 76),
                               },
                               Raw {
                                content: "'",
                                position: (1168, 78),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1168, 81),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "statePath",
                                    position: (1168, 85),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/config/initializers/smtp_settings.rb'\n",
                                position: (1168, 95),
                               },
                              ],
                             },
                            ],
                           },
                          },
                          Raw {
                           content: "\n",
                           position: (1169, 18),
                          },
                         ],
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\n\n(\n  umask u=rwx,g=,o=\n\n  openssl rand -hex 32 > ",
                      position: (1170, 14),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1175, 38),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1175, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/gitlab_shell_secret\n\n  rm -f ",
                      position: (1175, 52),
                     },
                     Raw {
                      content: "'",
                      position: (1177, 19),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1177, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1177, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/database.yml'\n\n  ",
                      position: (1177, 36),
                     },
                     Expression {
                      expression: IfThenElse {
                       predicate: BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1179, 18),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "databasePasswordFile",
                             position: (1179, 22),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (1179, 46),
                         },
                        ],
                        position: (1179, 43),
                       },
                       then: String {
                        parts: [
                         Raw {
                          content: "db_password=\"$(<",
                          position: (1180, 1),
                         },
                         Raw {
                          content: "'",
                          position: (1180, 33),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1180, 36),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "databasePasswordFile",
                              position: (1180, 40),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "')\"\nexport db_password\n\nif [[ -z \"$db_password\" ]]; then\n  >&2 echo \"Database password was an empty string!\"\n  exit 1\nfi\n\njq <",
                          position: (1180, 61),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1188, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "writeText",
                               position: (1188, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "database.yml",
                               position: (1188, 39),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (1188, 54),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "toJSON",
                                 position: (1188, 63),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "databaseConfig",
                               position: (1188, 70),
                              },
                             ],
                            },
                           ],
                          },
                         },
                         Raw {
                          content: " \\\n   '.production.password = $ENV.db_password' \\\n   >",
                          position: (1188, 86),
                         },
                         Raw {
                          content: "'",
                          position: (1190, 21),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1190, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "statePath",
                              position: (1190, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/config/database.yml'\n",
                          position: (1190, 38),
                         },
                        ],
                       },
                       else_: String {
                        parts: [
                         Raw {
                          content: "jq <",
                          position: (1193, 1),
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1193, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "writeText",
                               position: (1193, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "database.yml",
                               position: (1193, 39),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (1193, 54),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "toJSON",
                                 position: (1193, 63),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "databaseConfig",
                               position: (1193, 70),
                              },
                             ],
                            },
                           ],
                          },
                         },
                         Raw {
                          content: " \\\n   >",
                          position: (1193, 86),
                         },
                         Raw {
                          content: "'",
                          position: (1194, 21),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1194, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "statePath",
                              position: (1194, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/config/database.yml'\n",
                          position: (1194, 38),
                         },
                        ],
                       },
                       position: (1179, 15),
                      },
                     },
                     Raw {
                      content: "\n\n  ",
                      position: (1196, 14),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "utils",
                         position: (1198, 15),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "genJqSecretsReplacementSnippet",
                           position: (1198, 21),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "gitlabConfig",
                         position: (1199, 17),
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1200, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "statePath",
                               position: (1200, 24),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/config/gitlab.yml",
                           position: (1200, 34),
                          },
                         ],
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\n\n  rm -f ",
                      position: (1201, 14),
                     },
                     Raw {
                      content: "'",
                      position: (1203, 19),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1203, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1203, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/secrets.yml'\n\n  secret=\"$(<",
                      position: (1203, 36),
                     },
                     Raw {
                      content: "'",
                      position: (1205, 24),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1205, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1205, 31),
                         },
                         Raw {
                          content: "secretFile",
                          position: (1205, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  db=\"$(<",
                      position: (1205, 50),
                     },
                     Raw {
                      content: "'",
                      position: (1206, 20),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1206, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1206, 27),
                         },
                         Raw {
                          content: "dbFile",
                          position: (1206, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  otp=\"$(<",
                      position: (1206, 42),
                     },
                     Raw {
                      content: "'",
                      position: (1207, 21),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1207, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1207, 28),
                         },
                         Raw {
                          content: "otpFile",
                          position: (1207, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  jws=\"$(<",
                      position: (1207, 44),
                     },
                     Raw {
                      content: "'",
                      position: (1208, 21),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1208, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1208, 28),
                         },
                         Raw {
                          content: "jwsFile",
                          position: (1208, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  export secret db otp jws\n  jq -n '{production: {secret_key_base: $ENV.secret,\n          otp_key_base: $ENV.otp,\n          db_key_base: $ENV.db,\n          openid_connect_signing_key: $ENV.jws}}' \\\n     > ",
                      position: (1208, 44),
                     },
                     Raw {
                      content: "'",
                      position: (1214, 18),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1214, 21),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1214, 25),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/secrets.yml'\n)\n\n# We remove potentially broken links to old gitlab-shell versions\nrm -Rf ",
                      position: (1214, 35),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1218, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1218, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/repositories/**/*.git/hooks\n\ngit config --global core.autocrlf \"input\"\n",
                      position: (1218, 34),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1128, 23),
              },
             ),
            ],
            recursive: false,
            position: (1119, 38),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1225, 5),
             },
             Raw {
              content: "services",
              position: (1225, 13),
             },
             Raw {
              content: "gitlab-db-config",
              position: (1225, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1226, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                   position: (1226, 18),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-postgresql.service",
                   position: (1226, 42),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "postgresql.service",
                   position: (1226, 70),
                  },
                 ],
                },
               ],
               position: (1226, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1227, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1228, 10),
                    },
                   ],
                  },
                 ],
                 position: (1227, 17),
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1229, 12),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1229, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "databaseHost",
                          position: (1229, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [],
                      },
                     ],
                     position: (1229, 39),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "postgresql.service",
                       position: (1229, 47),
                      },
                     ],
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1230, 12),
                   },
                   arguments: [
                    Variable {
                     identifier: "databaseActuallyCreateLocally",
                     position: (1230, 21),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitlab-postgresql.service",
                       position: (1230, 52),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (1230, 9),
                },
               ],
               position: (1229, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1231, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1231, 21),
                  },
                 ],
                },
               ],
               position: (1231, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1232, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1232, 19),
                  },
                 ],
                },
               ],
               position: (1232, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1233, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1234, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "oneshot",
                    position: (1234, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1235, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1235, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1235, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1236, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1236, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1236, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1237, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1237, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1238, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (1238, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1239, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1239, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1239, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1239, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                    position: (1239, 51),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemainAfterExit",
                    position: (1240, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (1240, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1242, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1242, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "writeShellScript",
                      position: (1242, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab-db-config",
                      position: (1242, 44),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "set -o errexit -o pipefail -o nounset\nshopt -s inherit_errexit\numask u=rwx,g=rx,o=\n\ninitial_root_password=\"$(<",
                      position: (1243, 1),
                     },
                     Raw {
                      content: "'",
                      position: (1247, 37),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1247, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "initialRootPasswordFile",
                          position: (1247, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n",
                      position: (1247, 68),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "gitlab-rake",
                       position: (1248, 13),
                      },
                     },
                     Raw {
                      content: "/bin/gitlab-rake gitlab:db:configure GITLAB_ROOT_PASSWORD=\"$initial_root_password\" \\\n                                                   GITLAB_ROOT_EMAIL=",
                      position: (1248, 25),
                     },
                     Raw {
                      content: "'",
                      position: (1249, 80),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1249, 83),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "initialRootEmail",
                          position: (1249, 87),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "' > /dev/null\n",
                      position: (1249, 104),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1233, 23),
              },
             ),
            ],
            recursive: false,
            position: (1225, 41),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1254, 5),
             },
             Raw {
              content: "services",
              position: (1254, 13),
             },
             Raw {
              content: "gitlab-sidekiq",
              position: (1254, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1255, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                   position: (1256, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "redis-gitlab.service",
                   position: (1257, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "postgresql.service",
                   position: (1258, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                   position: (1259, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-db-config.service",
                   position: (1260, 10),
                  },
                 ],
                },
               ],
               position: (1255, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1262, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                     position: (1263, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1264, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-db-config.service",
                     position: (1265, 10),
                    },
                   ],
                  },
                 ],
                 position: (1262, 17),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (1266, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1266, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (1266, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                    },
                   ],
                   position: (1266, 39),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                     position: (1266, 47),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (1266, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1267, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1267, 21),
                  },
                 ],
                },
               ],
               position: (1267, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1268, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1268, 19),
                  },
                 ],
                },
               ],
               position: (1268, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1269, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Variable {
                 identifier: "gitlabEnv",
                 position: (1269, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (1269, 35),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1269, 49),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "sidekiq",
                      position: (1269, 53),
                     },
                     Raw {
                      content: "memoryKiller",
                      position: (1269, 61),
                     },
                     Raw {
                      content: "enable",
                      position: (1269, 74),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_MAX_RSS",
                        position: (1270, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1270, 41),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1270, 45),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1270, 53),
                        },
                        Raw {
                         content: "maxMemory",
                         position: (1270, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_GRACE_TIME",
                        position: (1271, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1271, 44),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1271, 48),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1271, 56),
                        },
                        Raw {
                         content: "graceTime",
                         position: (1271, 69),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_SHUTDOWN_WAIT",
                        position: (1272, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1272, 47),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1272, 51),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1272, 59),
                        },
                        Raw {
                         content: "shutdownWait",
                         position: (1272, 72),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1269, 81),
                  },
                 ],
                },
               ],
               position: (1269, 31),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1274, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1274, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (1275, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1276, 9),
                 },
                 Variable {
                  identifier: "ruby",
                  position: (1277, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1278, 9),
                 },
                 Variable {
                  identifier: "nodejs",
                  position: (1279, 9),
                 },
                 Variable {
                  identifier: "gnupg",
                  position: (1280, 9),
                 },
                 Variable {
                  identifier: "gnutar",
                  position: (1283, 9),
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1284, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1286, 9),
                 },
                ],
                position: (1274, 25),
               },
               position: (1274, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1288, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1289, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                    position: (1289, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1290, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1290, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1290, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1291, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1291, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1291, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1292, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1292, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1293, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "always",
                    position: (1293, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1294, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1294, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1294, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1294, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                    position: (1294, 51),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1295, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1295, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1295, 26),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1295, 35),
                       },
                       Raw {
                        content: "rubyEnv",
                        position: (1295, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/sidekiq -C \"",
                    position: (1295, 50),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1295, 70),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1295, 74),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1295, 83),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab/config/sidekiq_queues.yml\" -e production",
                    position: (1295, 90),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1288, 23),
              },
             ),
            ],
            recursive: false,
            position: (1254, 39),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1299, 5),
             },
             Raw {
              content: "services",
              position: (1299, 13),
             },
             Raw {
              content: "gitaly",
              position: (1299, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1300, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                   position: (1300, 18),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                   position: (1300, 35),
                  },
                 ],
                },
               ],
               position: (1300, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1301, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                   position: (1301, 20),
                  },
                 ],
                },
               ],
               position: (1301, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1302, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1302, 21),
                  },
                 ],
                },
               ],
               position: (1302, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1303, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1303, 19),
                  },
                 ],
                },
               ],
               position: (1303, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1304, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1304, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "openssh",
                  position: (1305, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1306, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1307, 9),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1308, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "packages",
                     position: (1308, 13),
                    },
                    Raw {
                     content: "gitaly",
                     position: (1308, 22),
                    },
                    Raw {
                     content: "rubyEnv",
                     position: (1308, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1309, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "packages",
                     position: (1309, 13),
                    },
                    Raw {
                     content: "gitaly",
                     position: (1309, 22),
                    },
                    Raw {
                     content: "rubyEnv",
                     position: (1309, 29),
                    },
                    Raw {
                     content: "wrappedRuby",
                     position: (1309, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1310, 9),
                 },
                 Variable {
                  identifier: "bzip2",
                  position: (1311, 9),
                 },
                ],
                position: (1304, 25),
               },
               position: (1304, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1313, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1314, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                    position: (1314, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1315, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1315, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1315, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1316, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1316, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1316, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1317, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1317, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1318, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (1318, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1319, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "gitlabEnv",
                   position: (1319, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "HOME",
                     position: (1319, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1320, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1320, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1320, 28),
                       },
                       Raw {
                        content: "gitaly",
                        position: (1320, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/gitaly ",
                    position: (1320, 44),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "gitalyToml",
                     position: (1320, 58),
                    },
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1313, 23),
              },
             ),
            ],
            recursive: false,
            position: (1299, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1324, 5),
             },
             Raw {
              content: "services",
              position: (1324, 13),
             },
             Raw {
              content: "gitlab-pages",
              position: (1324, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (1324, 37),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "gitlabConfig",
               position: (1324, 43),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "production",
                 position: (1324, 56),
                },
                Raw {
                 content: "pages",
                 position: (1324, 67),
                },
                Raw {
                 content: "enabled",
                 position: (1324, 73),
                },
               ],
              },
              default: Some(
               Variable {
                identifier: "false",
                position: (1324, 84),
               },
              ),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (1325, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GitLab static pages daemon",
                   position: (1325, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (1326, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (1326, 18),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1326, 35),
                    },
                   ],
                  },
                 ],
                 position: (1326, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bindsTo",
                   position: (1327, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1327, 20),
                    },
                   ],
                  },
                 ],
                 position: (1327, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (1328, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                     position: (1328, 21),
                    },
                   ],
                  },
                 ],
                 position: (1328, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "partOf",
                   position: (1329, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                     position: (1329, 19),
                    },
                   ],
                  },
                 ],
                 position: (1329, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1331, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1331, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "unzip",
                      position: (1331, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (1331, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1333, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Type",
                      position: (1334, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "simple",
                      position: (1334, 17),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeoutSec",
                      position: (1335, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "infinity",
                      position: (1335, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Restart",
                      position: (1336, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "on-failure",
                      position: (1336, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "User",
                      position: (1338, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1338, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1338, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Group",
                      position: (1339, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1339, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1339, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (1341, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1341, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1341, 28),
                         },
                         Raw {
                          content: "pages",
                          position: (1341, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/gitlab-pages ",
                      position: (1341, 43),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArgs",
                        position: (1341, 63),
                       },
                       arguments: [
                        Variable {
                         identifier: "pagesArgs",
                         position: (1341, 79),
                        },
                       ],
                      },
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "WorkingDirectory",
                      position: (1342, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "gitlabEnv",
                     position: (1342, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "HOME",
                       position: (1342, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1333, 23),
                },
               ),
              ],
              recursive: false,
              position: (1324, 91),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1346, 5),
             },
             Raw {
              content: "services",
              position: (1346, 13),
             },
             Raw {
              content: "gitlab-workhorse",
              position: (1346, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1347, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                   position: (1347, 18),
                  },
                 ],
                },
               ],
               position: (1347, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1348, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1348, 21),
                  },
                 ],
                },
               ],
               position: (1348, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1349, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1349, 19),
                  },
                 ],
                },
               ],
               position: (1349, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1350, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1350, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "exiftool",
                  position: (1351, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1352, 9),
                 },
                 Variable {
                  identifier: "gnutar",
                  position: (1353, 9),
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1354, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1355, 9),
                 },
                 Variable {
                  identifier: "gitlab-workhorse",
                  position: (1356, 9),
                 },
                ],
                position: (1350, 25),
               },
               position: (1350, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1358, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1359, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                    position: (1359, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1360, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1360, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1360, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1361, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1361, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1361, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1362, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1362, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1363, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (1363, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1364, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "gitlabEnv",
                   position: (1364, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "HOME",
                     position: (1364, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1365, 9),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     BinaryOperation {
                      operator: Addition,
                      operands: [
                       BinaryOperation {
                        operator: Addition,
                        operands: [
                         BinaryOperation {
                          operator: Addition,
                          operands: [
                           BinaryOperation {
                            operator: Addition,
                            operands: [
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1366, 14),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "packages",
                                    position: (1366, 18),
                                   },
                                   Raw {
                                    content: "gitlab-workhorse",
                                    position: (1366, 27),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/workhorse ",
                                position: (1366, 44),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "-listenUmask 0 ",
                                position: (1367, 14),
                               },
                              ],
                             },
                            ],
                            position: (1367, 11),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "-listenNetwork unix ",
                              position: (1368, 14),
                             },
                            ],
                           },
                          ],
                          position: (1368, 11),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "-listenAddr /run/gitlab/gitlab-workhorse.socket ",
                            position: (1369, 14),
                           },
                          ],
                         },
                        ],
                        position: (1369, 11),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "-authSocket ",
                          position: (1370, 14),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "gitlabSocket",
                           position: (1370, 28),
                          },
                         },
                         Raw {
                          content: " ",
                          position: (1370, 41),
                         },
                        ],
                       },
                      ],
                      position: (1370, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-documentRoot ",
                        position: (1371, 14),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1371, 30),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "packages",
                            position: (1371, 34),
                           },
                           Raw {
                            content: "gitlab",
                            position: (1371, 43),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/share/gitlab/public ",
                        position: (1371, 50),
                       },
                      ],
                     },
                    ],
                    position: (1371, 11),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-secretPath ",
                      position: (1372, 14),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1372, 28),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1372, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/.gitlab_workhorse_secret",
                      position: (1372, 42),
                     },
                    ],
                   },
                  ],
                  position: (1372, 11),
                 },
                ),
               ],
               recursive: false,
               position: (1358, 23),
              },
             ),
            ],
            recursive: false,
            position: (1346, 41),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1376, 5),
             },
             Raw {
              content: "services",
              position: (1376, 13),
             },
             Raw {
              content: "gitlab-mailroom",
              position: (1376, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (1376, 40),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "gitlabConfig",
               position: (1376, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "production",
                 position: (1376, 59),
                },
                Raw {
                 content: "incoming_email",
                 position: (1376, 70),
                },
                Raw {
                 content: "enabled",
                 position: (1376, 85),
                },
               ],
              },
              default: Some(
               Variable {
                identifier: "false",
                position: (1376, 96),
               },
              ),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (1377, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GitLab incoming mail daemon",
                   position: (1377, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (1378, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (1378, 18),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                     position: (1378, 35),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1378, 58),
                    },
                   ],
                  },
                 ],
                 position: (1378, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bindsTo",
                   position: (1379, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1379, 20),
                    },
                   ],
                  },
                 ],
                 position: (1379, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (1380, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                     position: (1380, 21),
                    },
                   ],
                  },
                 ],
                 position: (1380, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "partOf",
                   position: (1381, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                     position: (1381, 19),
                    },
                   ],
                  },
                 ],
                 position: (1381, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "environment",
                   position: (1382, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "gitlabEnv",
                 position: (1382, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1383, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Type",
                      position: (1384, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "simple",
                      position: (1384, 17),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeoutSec",
                      position: (1385, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "infinity",
                      position: (1385, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Restart",
                      position: (1386, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "on-failure",
                      position: (1386, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "User",
                      position: (1388, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1388, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1388, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Group",
                      position: (1389, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1389, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1389, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (1390, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1390, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1390, 28),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1390, 37),
                         },
                         Raw {
                          content: "rubyEnv",
                          position: (1390, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/bundle exec mail_room -c ",
                      position: (1390, 52),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1390, 84),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1390, 88),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/mail_room.yml",
                      position: (1390, 98),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "WorkingDirectory",
                      position: (1391, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "gitlabEnv",
                     position: (1391, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "HOME",
                       position: (1391, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1383, 23),
                },
               ),
              ],
              recursive: false,
              position: (1376, 103),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1395, 5),
             },
             Raw {
              content: "services",
              position: (1395, 13),
             },
             Raw {
              content: "gitlab",
              position: (1395, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1396, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-workhorse.service",
                   position: (1397, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                   position: (1398, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "redis-gitlab.service",
                   position: (1399, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                   position: (1400, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-db-config.service",
                   position: (1401, 10),
                  },
                 ],
                },
               ],
               position: (1396, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1403, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                     position: (1404, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                     position: (1405, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-db-config.service",
                     position: (1406, 10),
                    },
                   ],
                  },
                 ],
                 position: (1403, 17),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (1407, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1407, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (1407, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                    },
                   ],
                   position: (1407, 39),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                     position: (1407, 47),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (1407, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1408, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1408, 21),
                  },
                 ],
                },
               ],
               position: (1408, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1409, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                   position: (1409, 19),
                  },
                 ],
                },
               ],
               position: (1409, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1410, 7),
                },
               ],
              },
              Variable {
               identifier: "gitlabEnv",
               position: (1410, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1411, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1411, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (1412, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1413, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1414, 9),
                 },
                 Variable {
                  identifier: "nodejs",
                  position: (1415, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1416, 9),
                 },
                 Variable {
                  identifier: "gnupg",
                  position: (1417, 9),
                 },
                ],
                position: (1411, 25),
               },
               position: (1411, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1419, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1420, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "notify",
                    position: (1420, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1421, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1421, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1421, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1422, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1422, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1422, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1423, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                    position: (1423, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1424, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                    position: (1424, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1425, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1425, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1425, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1425, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                    position: (1425, 51),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1426, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "concatStringsSep",
                   position: (1426, 21),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: " ",
                      position: (1426, 39),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1427, 14),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "packages",
                            position: (1427, 18),
                           },
                           Raw {
                            content: "gitlab",
                            position: (1427, 27),
                           },
                           Raw {
                            content: "rubyEnv",
                            position: (1427, 34),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/puma",
                        position: (1427, 42),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-e production",
                        position: (1428, 12),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-C ",
                        position: (1429, 12),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1429, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "statePath",
                            position: (1429, 21),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/config/puma.rb",
                        position: (1429, 31),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-w ",
                        position: (1430, 12),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1430, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1430, 21),
                           },
                           Raw {
                            content: "workers",
                            position: (1430, 26),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-t ",
                        position: (1431, 12),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1431, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1431, 21),
                           },
                           Raw {
                            content: "threadsMin",
                            position: (1431, 26),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: ":",
                        position: (1431, 37),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1431, 40),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1431, 44),
                           },
                           Raw {
                            content: "threadsMax",
                            position: (1431, 49),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                     },
                    ],
                    position: (1426, 42),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1419, 23),
              },
             ),
            ],
            recursive: false,
            position: (1395, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1437, 5),
             },
             Raw {
              content: "services",
              position: (1437, 13),
             },
             Raw {
              content: "gitlab-backup",
              position: (1437, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1438, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.service",
                   position: (1438, 18),
                  },
                 ],
                },
               ],
               position: (1438, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1439, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.service",
                   position: (1439, 20),
                  },
                 ],
                },
               ],
               position: (1439, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "startAt",
                 position: (1440, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1440, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "backup",
                  position: (1440, 21),
                 },
                 Raw {
                  content: "startAt",
                  position: (1440, 28),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1441, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "RAILS_ENV",
                      position: (1442, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "production",
                      position: (1442, 22),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "CRON",
                      position: (1443, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "1",
                      position: (1443, 17),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1441, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (1444, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: GreaterThan,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "stringLength",
                      position: (1444, 27),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1444, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "backup",
                          position: (1444, 44),
                         },
                         Raw {
                          content: "skip",
                          position: (1444, 51),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (1444, 58),
                    },
                   ],
                   position: (1444, 56),
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SKIP",
                        position: (1445, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1445, 16),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "backup",
                         position: (1445, 20),
                        },
                        Raw {
                         content: "skip",
                         position: (1445, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1444, 61),
                  },
                 ],
                },
               ],
               position: (1444, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1447, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1448, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1448, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1448, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1449, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1449, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1449, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1450, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: Variable {
                     identifier: "gitlab-rake",
                     position: (1450, 24),
                    },
                   },
                   Raw {
                    content: "/bin/gitlab-rake gitlab:backup:create",
                    position: (1450, 36),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1447, 23),
              },
             ),
            ],
            recursive: false,
            position: (1437, 38),
           },
          ),
         ],
         recursive: false,
         position: (920, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (1456, 3),
        },
        Raw {
         content: "doc",
         position: (1456, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./gitlab.xml",
         position: (1456, 14),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (222, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}