---
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, 18),
     },
    ),
    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, 18),
     },
    ),
    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, 39),
          },
         ],
         position: (18, 38),
        },
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "%2F",
            },
           ],
           position: (18, 45),
          },
         ],
         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, 17),
             },
            ),
            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, 18),
             },
            ),
            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, 84),
         },
        ],
        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, 31),
       },
       String {
        parts: [
         Raw {
          content: "socket_path = \"",
         },
         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, 34),
              },
             ],
             position: (35, 33),
            },
            Variable {
             identifier: "gitalySocket",
             position: (35, 40),
            },
           ],
          },
         },
         Raw {
          content: "\"\nbin_dir = \"",
         },
         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 = \"",
         },
         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 = \"",
         },
         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 = \"",
         },
         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 = \"",
         },
         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 = \"",
         },
         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://",
         },
         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",
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (58, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
              },
             ],
             position: (58, 24),
            },
            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 = \"",
                    },
                    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, 27),
                         },
                        ],
                        position: (60, 26),
                       },
                       Variable {
                        identifier: "k",
                        position: (60, 33),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\"\npath = \"",
                    },
                    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, 27),
                         },
                        ],
                        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: (58, 58),
                  },
                  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: (34, 45),
       },
      ],
     },
    ),
    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://",
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "pathUrlQuote",
               position: (67, 33),
              },
              arguments: [
               Variable {
                identifier: "gitlabSocket",
                position: (67, 46),
               },
              ],
             },
            },
           ],
           position: (67, 18),
          },
         ),
         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, 18),
          },
         ),
         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, 19),
          },
         ),
         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, 16),
          },
         ),
         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, 13),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "host",
                position: (74, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "127.0.0.1",
               },
              ],
              position: (74, 14),
             },
            ),
            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, 19),
             },
            ),
           ],
           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, 5),
         },
         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, 5),
         },
         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, 19),
         },
        ],
        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, 30),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "email_reply_to",
                   position: (98, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "noreply@localhost",
                  },
                 ],
                 position: (98, 26),
                },
               ),
               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, 44),
             },
            ),
            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:",
               },
               Expression {
                expression: Variable {
                 identifier: "gitalySocket",
                 position: (110, 62),
                },
               },
              ],
              position: (110, 54),
             },
            ),
            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, 31),
             },
            ),
            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, 21),
             },
            ),
            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, 28),
             },
            ),
            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, 30),
                  },
                 ),
                 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,
                   },
                  },
                 ],
                 position: (128, 16),
                },
               ),
               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, 22),
                },
               ),
               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, 23),
                },
               ),
               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, 31),
             },
            ),
            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, 32),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "git",
                position: (136, 7),
               },
               Raw {
                content: "bin_path",
                position: (136, 11),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "git",
               },
              ],
              position: (136, 22),
             },
            ),
            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, 26),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "::1/128",
                    },
                   ],
                   position: (138, 40),
                  },
                 ],
                 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, 21),
                   },
                  ),
                  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://",
                    },
                    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: ":",
                    },
                    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, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "issuer",
                     position: (151, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-issuer",
                    },
                   ],
                   position: (151, 18),
                  },
                 ),
                ],
                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, 12),
            },
           ),
           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, 17),
            },
           ),
           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, 19),
            },
           ),
           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, 14),
            },
           ),
           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, 27),
            },
           ),
           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, 23),
            },
           ),
           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, 47),
              },
              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, 32),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "RAILS_ENV",
               position: (167, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "production",
              },
             ],
             position: (167, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "MALLOC_ARENA_MAX",
               position: (168, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "2",
              },
             ],
             position: (168, 24),
            },
           ),
          ],
          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, 12),
          },
         ),
         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 ",
            },
            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    ",
            },
            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 ",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (179, 66),
                      },
                     },
                     Raw {
                      content: " '",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "value",
                       position: (179, 75),
                      },
                     },
                     Raw {
                      content: "' ",
                     },
                    ],
                    position: (179, 57),
                   },
                   position: (179, 50),
                  },
                  position: (179, 44),
                 },
                 Variable {
                  identifier: "gitlabEnv",
                  position: (179, 86),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " \\\n    --set PATH ",
            },
            Raw {
             content: "'",
            },
            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 ",
            },
            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 ",
            },
            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: (176, 20),
          },
         ),
        ],
        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, 12),
          },
         ),
         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 ",
            },
            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    ",
            },
            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 ",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "name",
                       position: (194, 66),
                      },
                     },
                     Raw {
                      content: " '",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "value",
                       position: (194, 75),
                      },
                     },
                     Raw {
                      content: "' ",
                     },
                    ],
                    position: (194, 57),
                   },
                   position: (194, 50),
                  },
                  position: (194, 44),
                 },
                 Variable {
                  identifier: "gitlabEnv",
                  position: (194, 86),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: " \\\n    --set PATH ",
            },
            Raw {
             content: "'",
            },
            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 ",
            },
            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: (191, 20),
          },
         ),
        ],
        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, 34),
       },
       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, 33),
       },
       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: \"",
         },
         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: ",
         },
         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    ",
         },
         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: \"",
              },
              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, 54),
            },
           ],
          },
         },
         Raw {
          content: "\n    ",
         },
         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, 58),
            },
           ],
          },
         },
         Raw {
          content: "\n    domain: \"",
         },
         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    ",
         },
         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: :",
              },
              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, 60),
            },
           ],
          },
         },
         Raw {
          content: "\n    enable_starttls_auto: ",
         },
         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: ",
         },
         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: ",
         },
         Raw {
          content: "'",
         },
         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: (202, 59),
       },
      ],
     },
    ),
   ],
   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, 30),
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
              },
             ],
             position: (225, 41),
            },
            String {
             parts: [
              Raw {
               content: "stateDir",
              },
             ],
             position: (225, 50),
            },
           ],
           position: (225, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (225, 65),
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
              },
             ],
             position: (225, 76),
            },
            String {
             parts: [
              Raw {
               content: "statePath",
              },
             ],
             position: (225, 85),
            },
           ],
           position: (225, 63),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (226, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (226, 30),
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
              },
             ],
             position: (226, 41),
            },
            String {
             parts: [
              Raw {
               content: "backupPath",
              },
             ],
             position: (226, 50),
            },
           ],
           position: (226, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (226, 67),
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
              },
             ],
             position: (226, 78),
            },
            String {
             parts: [
              Raw {
               content: "backup",
              },
             ],
             position: (226, 87),
            },
            String {
             parts: [
              Raw {
               content: "path",
              },
             ],
             position: (226, 96),
            },
           ],
           position: (226, 65),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (227, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
              },
             ],
             position: (227, 30),
            },
            String {
             parts: [
              Raw {
               content: "gitlab",
              },
             ],
             position: (227, 41),
            },
            String {
             parts: [
              Raw {
               content: "satelliteDir",
              },
             ],
             position: (227, 50),
            },
           ],
           position: (227, 28),
          },
          String {
           parts: [],
           position: (227, 67),
          },
         ],
        },
       ],
       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: (235, 23),
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (244, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab package",
                   },
                  ],
                  position: (244, 23),
                 },
                ),
                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, 37),
                   },
                  ],
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (252, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-shell package",
                   },
                  ],
                  position: (252, 23),
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (259, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-workhorse package",
                   },
                  ],
                  position: (259, 23),
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (266, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitaly package",
                   },
                  ],
                  position: (266, 23),
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (273, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Reference to the gitlab-pages package",
                   },
                  ],
                  position: (273, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                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: (279, 23),
                 },
                ),
               ],
               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: (293, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                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: (302, 23),
                 },
                ),
               ],
               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, 35),
                   },
                  ],
                  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.",
                     },
                     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, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (314, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab path for backups.",
                   },
                  ],
                  position: (314, 23),
                 },
                ),
               ],
               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: (322, 23),
                 },
                ),
               ],
               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, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "uploads",
                           },
                          ],
                          position: (333, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "builds",
                           },
                          ],
                          position: (334, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "artifacts",
                           },
                          ],
                          position: (335, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "lfs",
                           },
                          ],
                          position: (336, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "registry",
                           },
                          ],
                          position: (337, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "pages",
                           },
                          ],
                          position: (338, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "repositories",
                           },
                          ],
                          position: (339, 17),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "tar",
                           },
                          ],
                          position: (340, 17),
                         },
                        ],
                        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, 21),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "lfs",
                     },
                    ],
                    position: (345, 33),
                   },
                  ],
                  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, 63),
                     },
                     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: (347, 23),
                 },
                ),
               ],
               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: (361, 37),
                   },
                  ],
                 },
                ),
                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: (386, 23),
                 },
                ),
               ],
               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: [],
                  position: (398, 19),
                 },
                ),
                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: (399, 23),
                 },
                ),
               ],
               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: (408, 23),
                 },
                ),
               ],
               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: (419, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (430, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab database name.",
                   },
                  ],
                  position: (430, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (436, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "GitLab database user.",
                   },
                  ],
                  position: (436, 23),
                 },
                ),
               ],
               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, 23),
                 },
                ),
               ],
               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, 23),
                 },
                ),
               ],
               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:",
                   },
                   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, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (454, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (454, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "redis://localhost:",
                     },
                     Raw {
                      content: "$",
                     },
                     Raw {
                      content: "{toString config.services.redis.servers.gitlab.port}/",
                     },
                    ],
                    position: (454, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (455, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Redis URL for all GitLab services except gitlab-shell",
                   },
                  ],
                  position: (455, 23),
                 },
                ),
               ],
               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: [],
                  position: (460, 19),
                 },
                ),
                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: (461, 19),
                 },
                ),
                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: (471, 23),
                 },
                ),
               ],
               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, 41),
                   },
                  ],
                 },
                ),
                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, 23),
                 },
                ),
               ],
               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: (488, 23),
                 },
                ),
               ],
               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, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (503, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User to run gitlab and all related services.",
                   },
                  ],
                  position: (503, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (509, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group to run gitlab and all related services.",
                   },
                  ],
                  position: (509, 23),
                 },
                ),
               ],
               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, 19),
                 },
                ),
                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: (515, 23),
                 },
                ),
               ],
               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: (523, 23),
                 },
                ),
               ],
               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, 25),
                    },
                   ),
                  ],
                  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, 43),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (542, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry host name.",
                      },
                     ],
                     position: (542, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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.",
                        },
                        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,
                         },
                        },
                       ],
                       position: (560, 43),
                      },
                     ],
                    },
                   ),
                   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, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (566, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry issuer.",
                      },
                     ],
                     position: (566, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (571, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "GitLab container registry service name.",
                      },
                     ],
                     position: (571, 25),
                    },
                   ),
                  ],
                  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: [],
                     position: (575, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (576, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "External address used to access registry from the internet",
                      },
                     ],
                     position: (576, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (594, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Address of the SMTP server for GitLab.",
                      },
                     ],
                     position: (594, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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: (612, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (623, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "HELO domain to use for outgoing mail.",
                      },
                     ],
                     position: (623, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   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, 25),
                    },
                   ),
                  ],
                  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, 21),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "127.0.0.1:8090",
                     },
                    ],
                    position: (653, 37),
                   },
                  ],
                  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, 23),
                 },
                ),
               ],
               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: (660, 23),
                 },
                ),
               ],
               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: (676, 23),
                 },
                ),
               ],
               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: (692, 23),
                 },
                ),
               ],
               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: (708, 23),
                 },
                ),
               ],
               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, 23),
                 },
                ),
               ],
               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: (733, 23),
                 },
                ),
               ],
               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: (752, 23),
                 },
                ),
               ],
               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: (769, 23),
                 },
                ),
               ],
               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: (788, 23),
                 },
                ),
               ],
               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: (802, 23),
                 },
                ),
               ],
               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: (812, 23),
                 },
                ),
               ],
               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: (822, 23),
                 },
                ),
               ],
               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: (832, 25),
                    },
                   ),
                  ],
                  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, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (840, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "How often to rotate the logs.",
                      },
                     ],
                     position: (840, 25),
                    },
                   ),
                  ],
                  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, 25),
                    },
                   ),
                  ],
                  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: [],
                     position: (851, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (852, 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: (852, 25),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (849, 32),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (828, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (859, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (859, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (860, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (860, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (860, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (861, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (861, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (862, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (862, 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: (862, 37),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (897, 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: (897, 23),
                 },
                ),
               ],
               recursive: false,
               position: (859, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (231, 23),
         },
        ),
       ],
       recursive: false,
       position: (230, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (917, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (917, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (917, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (917, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (919, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (921, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  Variable {
                   identifier: "databaseActuallyCreateLocally",
                   position: (921, 21),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (921, 55),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "user",
                        position: (921, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (921, 67),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (921, 71),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (921, 64),
                  },
                 ],
                 position: (921, 51),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (922, 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: (922, 19),
                },
               ),
              ],
              recursive: false,
              position: (920, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (925, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (925, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (925, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                     position: (925, 42),
                    },
                   ],
                   position: (925, 39),
                  },
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (925, 50),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databasePasswordFile",
                        position: (925, 54),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (925, 78),
                    },
                   ],
                   position: (925, 75),
                  },
                 ],
                 position: (925, 46),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (926, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "When services.gitlab.databaseHost is customized, services.gitlab.databasePasswordFile must be set!",
                  },
                 ],
                 position: (926, 19),
                },
               ),
              ],
              recursive: false,
              position: (924, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (929, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (929, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "initialRootPasswordFile",
                      position: (929, 25),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (929, 52),
                  },
                 ],
                 position: (929, 49),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (930, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.initialRootPasswordFile must be set!",
                  },
                 ],
                 position: (930, 19),
                },
               ),
              ],
              recursive: false,
              position: (928, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (933, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (933, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (933, 25),
                     },
                     Raw {
                      content: "secretFile",
                      position: (933, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (933, 47),
                  },
                 ],
                 position: (933, 44),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (934, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.secretFile must be set!",
                  },
                 ],
                 position: (934, 19),
                },
               ),
              ],
              recursive: false,
              position: (932, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (937, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (937, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (937, 25),
                     },
                     Raw {
                      content: "dbFile",
                      position: (937, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (937, 43),
                  },
                 ],
                 position: (937, 40),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (938, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.dbFile must be set!",
                  },
                 ],
                 position: (938, 19),
                },
               ),
              ],
              recursive: false,
              position: (936, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (941, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (941, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (941, 25),
                     },
                     Raw {
                      content: "otpFile",
                      position: (941, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (941, 44),
                  },
                 ],
                 position: (941, 41),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (942, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.otpFile must be set!",
                  },
                 ],
                 position: (942, 19),
                },
               ),
              ],
              recursive: false,
              position: (940, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (945, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (945, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "secrets",
                      position: (945, 25),
                     },
                     Raw {
                      content: "jwsFile",
                      position: (945, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (945, 44),
                  },
                 ],
                 position: (945, 41),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (946, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab.secrets.jwsFile must be set!",
                  },
                 ],
                 position: (946, 19),
                },
               ),
              ],
              recursive: false,
              position: (944, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (949, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "versionAtLeast",
                  position: (949, 21),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "postgresqlPackage",
                    position: (949, 36),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "version",
                      position: (949, 54),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "12.0.0",
                    },
                   ],
                   position: (949, 62),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (950, 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: (950, 19),
                },
               ),
              ],
              recursive: false,
              position: (948, 7),
             },
            ],
            position: (919, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (954, 5),
             },
             Raw {
              content: "systemPackages",
              position: (954, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (954, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "git",
                 position: (954, 41),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "gitlab-rake",
              position: (954, 45),
             },
             Variable {
              identifier: "gitlab-rails",
              position: (954, 57),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (954, 70),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "packages",
                 position: (954, 74),
                },
                Raw {
                 content: "gitlab-shell",
                 position: (954, 83),
                },
               ],
              },
              default: None,
             },
            ],
            position: (954, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (956, 5),
             },
             Raw {
              content: "targets",
              position: (956, 13),
             },
             Raw {
              content: "gitlab",
              position: (956, 21),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (957, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Common target for all GitLab services.",
                },
               ],
               position: (957, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (958, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                  },
                 ],
                 position: (958, 20),
                },
               ],
               position: (958, 18),
              },
             ),
            ],
            recursive: false,
            position: (956, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (962, 5),
             },
             Raw {
              content: "redis",
              position: (962, 14),
             },
             Raw {
              content: "servers",
              position: (962, 20),
             },
             Raw {
              content: "gitlab",
              position: (962, 28),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (963, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (963, 16),
               },
               arguments: [
                Variable {
                 identifier: "true",
                 position: (963, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (964, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (964, 14),
               },
               arguments: [
                Int {
                 value: 31636,
                 position: (964, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bind",
                 position: (965, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (965, 14),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "127.0.0.1",
                  },
                 ],
                 position: (965, 24),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (962, 37),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (969, 5),
             },
             Raw {
              content: "postgresql",
              position: (969, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (969, 27),
            },
            arguments: [
             Variable {
              identifier: "databaseActuallyCreateLocally",
              position: (969, 41),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (970, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (970, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ensureUsers",
                   position: (971, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "singleton",
                  position: (971, 21),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (971, 33),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (971, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "databaseUsername",
                         position: (971, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (971, 31),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (969, 71),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (975, 5),
             },
             Raw {
              content: "logrotate",
              position: (975, 14),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (976, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (976, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "logrotate",
                  position: (976, 20),
                 },
                 Raw {
                  content: "enable",
                  position: (976, 30),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "settings",
                 position: (977, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "gitlab",
                    position: (978, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "files",
                       position: (979, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (979, 22),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (979, 26),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/log/*.log",
                      },
                     ],
                     position: (979, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "su",
                       position: (980, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (980, 19),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (980, 23),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: " ",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (980, 31),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (980, 35),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                     ],
                     position: (980, 16),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "frequency",
                       position: (981, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (981, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (981, 27),
                       },
                       Raw {
                        content: "frequency",
                        position: (981, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "rotate",
                       position: (982, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (982, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (982, 24),
                       },
                       Raw {
                        content: "keep",
                        position: (982, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "copytruncate",
                       position: (983, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (983, 26),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "compress",
                       position: (984, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (984, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "extraConfig",
                       position: (985, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (985, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "logrotate",
                        position: (985, 29),
                       },
                       Raw {
                        content: "extraConfig",
                        position: (985, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (978, 18),
                 },
                ),
               ],
               recursive: false,
               position: (977, 18),
              },
             ),
            ],
            recursive: false,
            position: (975, 26),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (993, 5),
             },
             Raw {
              content: "services",
              position: (993, 13),
             },
             Raw {
              content: "gitlab-postgresql",
              position: (993, 22),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "pgsql",
                 position: (993, 46),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (993, 54),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (993, 61),
                 },
                 Raw {
                  content: "postgresql",
                  position: (993, 70),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            target: FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (993, 85),
             },
             arguments: [
              Variable {
               identifier: "databaseActuallyCreateLocally",
               position: (993, 90),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (994, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "postgresql.service",
                     },
                    ],
                    position: (994, 17),
                   },
                  ],
                  position: (994, 15),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "bindsTo",
                    position: (995, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "postgresql.service",
                     },
                    ],
                    position: (995, 19),
                   },
                  ],
                  position: (995, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (996, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab.target",
                     },
                    ],
                    position: (996, 20),
                   },
                  ],
                  position: (996, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "partOf",
                    position: (997, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab.target",
                     },
                    ],
                    position: (997, 18),
                   },
                  ],
                  position: (997, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (998, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "pgsql",
                     position: (999, 9),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (999, 15),
                      },
                     ],
                    },
                    default: None,
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (1000, 9),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "util-linux",
                       position: (1000, 14),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                  position: (998, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "script",
                    position: (1002, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "set -eu\n\nPSQL() {\n    psql --port=",
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (1006, 27),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "pgsql",
                        position: (1006, 36),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "port",
                          position: (1006, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: " \"$@\"\n}\n\nPSQL -tAc \"SELECT 1 FROM pg_database WHERE datname = ",
                   },
                   Raw {
                    content: "'",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1009, 65),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1009, 69),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "'\" | grep -q 1 || PSQL -tAc 'CREATE DATABASE \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1009, 130),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1009, 134),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" OWNER \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1009, 158),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1009, 162),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"'\ncurrent_owner=$(PSQL -tAc \"SELECT pg_catalog.pg_get_userbyid(datdba) FROM pg_catalog.pg_database WHERE datname = ",
                   },
                   Raw {
                    content: "'",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1010, 125),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1010, 129),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "'\")\nif [[ \"$current_owner\" != \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1011, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1011, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" ]]; then\n    PSQL -tAc 'ALTER DATABASE \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1012, 42),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1012, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" OWNER TO \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1012, 73),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1012, 77),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"'\n    if [[ -e \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1013, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1013, 32),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1013, 41),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1013, 52),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1013, 76),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1013, 80),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" ]]; then\n        echo \"Reassigning ownership of database ",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1014, 59),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1014, 63),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: " to user ",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1014, 87),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1014, 91),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: " failed on last boot. Failing...\"\n        exit 1\n    fi\n    touch \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1017, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1017, 29),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1017, 38),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1017, 49),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1017, 73),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1017, 77),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"\n    PSQL \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1018, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1018, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" -tAc \"REASSIGN OWNED BY \\\"$current_owner\\\" TO \\\"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1018, 90),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseUsername",
                        position: (1018, 94),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\\\"\"\n    rm \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1019, 19),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1019, 26),
                       },
                       Raw {
                        content: "postgresql",
                        position: (1019, 35),
                       },
                       Raw {
                        content: "dataDir",
                        position: (1019, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/.reassigning_",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1019, 70),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1019, 74),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\"\nfi\nPSQL ",
                   },
                   Raw {
                    content: "'",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1021, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1021, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "' -tAc \"CREATE EXTENSION IF NOT EXISTS pg_trgm\"\nPSQL ",
                   },
                   Raw {
                    content: "'",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1022, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseName",
                        position: (1022, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "' -tAc \"CREATE EXTENSION IF NOT EXISTS btree_gist;\"\n",
                   },
                  ],
                  position: (1002, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1025, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "User",
                       position: (1026, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pgsql",
                      position: (1026, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "superUser",
                        position: (1026, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Type",
                       position: (1027, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "oneshot",
                      },
                     ],
                     position: (1027, 16),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RemainAfterExit",
                       position: (1028, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (1028, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1025, 23),
                 },
                ),
               ],
               recursive: false,
               position: (993, 120),
              },
             ],
            },
            position: (993, 42),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1032, 5),
             },
             Raw {
              content: "services",
              position: (1032, 13),
             },
             Raw {
              content: "gitlab-registry-cert",
              position: (1032, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1032, 45),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1032, 59),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1032, 63),
                },
                Raw {
                 content: "enable",
                 position: (1032, 72),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1033, 7),
                  },
                 ],
                },
                With {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (1033, 19),
                 },
                 target: List {
                  elements: [
                   Variable {
                    identifier: "openssl",
                    position: (1033, 27),
                   },
                  ],
                  position: (1033, 25),
                 },
                 position: (1033, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "script",
                   position: (1035, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mkdir -p $(dirname ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1036, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1036, 34),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1036, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nmkdir -p $(dirname ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1037, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1037, 34),
                      },
                      Raw {
                       content: "certFile",
                       position: (1037, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nopenssl req -nodes -newkey rsa:4096 -keyout ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1038, 55),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1038, 59),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1038, 68),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -out /tmp/registry-auth.csr -subj \"/CN=",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1038, 118),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1038, 122),
                      },
                      Raw {
                       content: "issuer",
                       position: (1038, 131),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\"\nopenssl x509 -in /tmp/registry-auth.csr -out ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1039, 56),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1039, 60),
                      },
                      Raw {
                       content: "certFile",
                       position: (1039, 69),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -req -signkey ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1039, 95),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1039, 99),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1039, 108),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " -days 3650\nchown ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1040, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1040, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1040, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1040, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " $(dirname ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1040, 52),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1040, 56),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1040, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nchown ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1041, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1041, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1041, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1041, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " $(dirname ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1041, 52),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1041, 56),
                      },
                      Raw {
                       content: "certFile",
                       position: (1041, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\nchown ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1042, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1042, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1042, 42),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1042, 46),
                      },
                      Raw {
                       content: "keyFile",
                       position: (1042, 55),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\nchown ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1043, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1043, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: " ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1043, 42),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "registry",
                       position: (1043, 46),
                      },
                      Raw {
                       content: "certFile",
                       position: (1043, 55),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n",
                  },
                 ],
                 position: (1035, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1046, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ConditionPathExists",
                      position: (1047, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "!",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1047, 35),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1047, 39),
                         },
                         Raw {
                          content: "certFile",
                          position: (1047, 48),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                    ],
                    position: (1047, 31),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1046, 23),
                },
               ),
              ],
              recursive: false,
              position: (1032, 79),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1052, 5),
             },
             Raw {
              content: "services",
              position: (1052, 13),
             },
             Raw {
              content: "docker-registry",
              position: (1052, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1052, 40),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1052, 54),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1052, 58),
                },
                Raw {
                 content: "enable",
                 position: (1052, 67),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wants",
                   position: (1053, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-registry-cert.service",
                    },
                   ],
                   position: (1053, 17),
                  },
                 ],
                 position: (1053, 15),
                },
               ),
              ],
              recursive: false,
              position: (1052, 74),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (1057, 5),
             },
             Raw {
              content: "dockerRegistry",
              position: (1057, 14),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalAttrs",
             position: (1057, 31),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (1057, 45),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "registry",
                 position: (1057, 49),
                },
                Raw {
                 content: "enable",
                 position: (1057, 58),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enable",
                   position: (1058, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (1058, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "enableDelete",
                   position: (1059, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (1059, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "extraConfig",
                   position: (1060, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "auth",
                      position: (1061, 9),
                     },
                     Raw {
                      content: "token",
                      position: (1061, 14),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "realm",
                         position: (1062, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "http",
                        },
                        Expression {
                         expression: IfThenElse {
                          predicate: BinaryOperation {
                           operator: EqualTo,
                           operands: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (1062, 29),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "https",
                                position: (1062, 33),
                               },
                              ],
                             },
                             default: None,
                            },
                            Variable {
                             identifier: "true",
                             position: (1062, 42),
                            },
                           ],
                           position: (1062, 39),
                          },
                          then: String {
                           parts: [
                            Raw {
                             content: "s",
                            },
                           ],
                           position: (1062, 52),
                          },
                          else_: String {
                           parts: [],
                           position: (1062, 61),
                          },
                          position: (1062, 26),
                         },
                        },
                        Raw {
                         content: "://",
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1062, 69),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "host",
                             position: (1062, 73),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/jwt/auth",
                        },
                       ],
                       position: (1062, 19),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "service",
                         position: (1063, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1063, 21),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1063, 25),
                         },
                         Raw {
                          content: "serviceName",
                          position: (1063, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "issuer",
                         position: (1064, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1064, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1064, 24),
                         },
                         Raw {
                          content: "issuer",
                          position: (1064, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "rootcertbundle",
                         position: (1065, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1065, 28),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registry",
                          position: (1065, 32),
                         },
                         Raw {
                          content: "certFile",
                          position: (1065, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                    ],
                    recursive: false,
                    position: (1061, 22),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1060, 21),
                },
               ),
              ],
              recursive: false,
              position: (1057, 65),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (1071, 5),
             },
             Raw {
              content: "postfix",
              position: (1071, 14),
             },
             Raw {
              content: "enable",
              position: (1071, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (1071, 31),
            },
            arguments: [
             BinaryOperation {
              operator: LogicalAnd,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (1071, 42),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "smtp",
                   position: (1071, 46),
                  },
                  Raw {
                   content: "enable",
                   position: (1071, 51),
                  },
                 ],
                },
                default: None,
               },
               BinaryOperation {
                operator: EqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1071, 61),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "smtp",
                     position: (1071, 65),
                    },
                    Raw {
                     content: "address",
                     position: (1071, 70),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                   },
                  ],
                  position: (1071, 81),
                 },
                ],
                position: (1071, 78),
               },
              ],
              position: (1071, 58),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (1073, 5),
             },
             Raw {
              content: "users",
              position: (1073, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1073, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "user",
                  position: (1073, 23),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (1074, 9),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1074, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1074, 21),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (1075, 9),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1075, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "statePath",
                     position: (1075, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/home",
                },
               ],
               position: (1075, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "shell",
                 position: (1076, 9),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1076, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bash",
                     position: (1076, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/bash",
                },
               ],
               position: (1076, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (1077, 9),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (1077, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (1077, 22),
                 },
                 Raw {
                  content: "uids",
                  position: (1077, 26),
                 },
                 Raw {
                  content: "gitlab",
                  position: (1077, 31),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (1074, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (1080, 5),
             },
             Raw {
              content: "groups",
              position: (1080, 11),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1080, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1080, 24),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "gid",
              position: (1080, 31),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1080, 37),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (1080, 44),
              },
              Raw {
               content: "gids",
               position: (1080, 48),
              },
              Raw {
               content: "gitlab",
               position: (1080, 53),
              },
             ],
            },
            default: None,
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1082, 5),
             },
             Raw {
              content: "tmpfiles",
              position: (1082, 13),
             },
             Raw {
              content: "rules",
              position: (1082, 22),
             },
            ],
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "d /run/gitlab 0755 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1083, 29),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1083, 33),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1083, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1083, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1083, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabEnv",
                  position: (1084, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "HOME",
                    position: (1084, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1084, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1084, 39),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1084, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1084, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1084, 7),
             },
             String {
              parts: [
               Raw {
                content: "z ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabEnv",
                  position: (1085, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "HOME",
                    position: (1085, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/.ssh/authorized_keys 0600 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1085, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1085, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1085, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1085, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1085, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1086, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "backup",
                    position: (1086, 16),
                   },
                   Raw {
                    content: "path",
                    position: (1086, 23),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1086, 36),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1086, 40),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1086, 48),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1086, 52),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1086, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1087, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1087, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1087, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1087, 38),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1087, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1087, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1087, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1088, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/builds 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1088, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1088, 53),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1088, 57),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1088, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1089, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/config 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1089, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1089, 53),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1089, 57),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1089, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1090, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/db 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1090, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1090, 49),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1090, 53),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1090, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1091, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1091, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1091, 50),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1091, 54),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1091, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1092, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/repositories 2770 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1092, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1092, 59),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1092, 63),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1092, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1093, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/shell 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1093, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1093, 52),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1093, 56),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1093, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1094, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1094, 42),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1094, 50),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1094, 54),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1094, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1095, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp/pids 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 43),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1095, 47),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1095, 55),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1095, 59),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1095, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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/sockets 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1096, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1096, 50),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1096, 58),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1096, 62),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1096, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1097, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/uploads 0700 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 42),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1097, 46),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1097, 54),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1097, 58),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1097, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1098, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks 0700 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1098, 51),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1098, 59),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1098, 63),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1098, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1099, 16),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/custom_hooks/pre-receive.d 0700 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 61),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1099, 65),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1099, 73),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1099, 77),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1099, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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/post-receive.d 0700 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1100, 62),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1100, 66),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1100, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1100, 78),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1100, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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/update.d 0700 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1101, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1101, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1101, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1101, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1101, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1102, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1102, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1102, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1102, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1102, 56),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1102, 60),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1102, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1102, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1102, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "gitlabConfig",
                  position: (1103, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "production",
                    position: (1103, 25),
                   },
                   Raw {
                    content: "shared",
                    position: (1103, 36),
                   },
                   Raw {
                    content: "path",
                    position: (1103, 43),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/artifacts 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1103, 66),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1103, 70),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1103, 78),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1103, 82),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1103, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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: "/lfs-objects 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1104, 68),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1104, 72),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1104, 80),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1104, 84),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1104, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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: "/packages 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1105, 65),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1105, 69),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1105, 77),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1105, 81),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1105, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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: "/pages 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1106, 62),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1106, 66),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1106, 74),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1106, 78),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1106, 7),
             },
             String {
              parts: [
               Raw {
                content: "d ",
               },
               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: "/terraform_state 0750 ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1107, 72),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (1107, 76),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1107, 84),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (1107, 88),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " -",
               },
              ],
              position: (1107, 7),
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/config - - - - ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1108, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1108, 44),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/config",
               },
              ],
              position: (1108, 7),
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/log - - - - ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1109, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1109, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/log",
               },
              ],
              position: (1109, 7),
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/tmp - - - - ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1110, 37),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1110, 41),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/tmp",
               },
              ],
              position: (1110, 7),
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/uploads - - - - ",
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1111, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "statePath",
                    position: (1111, 45),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/uploads",
               },
              ],
              position: (1111, 7),
             },
             String {
              parts: [
               Raw {
                content: "L+ /run/gitlab/shell-config.yml - - - - ",
               },
               Expression {
                expression: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1113, 50),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "writeText",
                     position: (1113, 55),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "config.yml",
                    },
                   ],
                   position: (1113, 65),
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (1113, 79),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "toJSON",
                       position: (1113, 88),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "gitlabShellConfig",
                     position: (1113, 95),
                    },
                   ],
                  },
                 ],
                },
               },
              ],
              position: (1113, 7),
             },
            ],
            position: (1082, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1117, 5),
             },
             Raw {
              content: "services",
              position: (1117, 13),
             },
             Raw {
              content: "gitlab-config",
              position: (1117, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1118, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1118, 20),
                },
               ],
               position: (1118, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1119, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1119, 18),
                },
               ],
               position: (1119, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1120, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1120, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "jq",
                  position: (1121, 9),
                 },
                 Variable {
                  identifier: "openssl",
                  position: (1122, 9),
                 },
                 Variable {
                  identifier: "replace-secret",
                  position: (1123, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1124, 9),
                 },
                ],
                position: (1120, 25),
               },
               position: (1120, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1126, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1127, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "oneshot",
                   },
                  ],
                  position: (1127, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1128, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1128, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1128, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1129, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1129, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1129, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1130, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1130, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1131, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (1131, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1132, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1132, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1132, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1132, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                   },
                  ],
                  position: (1132, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemainAfterExit",
                    position: (1133, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (1133, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStartPre",
                    position: (1135, 9),
                   },
                  ],
                 },
                 LetIn {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "preStartFullPrivileges",
                       position: (1136, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "set -o errexit -o pipefail -o nounset\nshopt -s dotglob nullglob inherit_errexit\n\nchown --no-dereference ",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1140, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (1140, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "':",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1140, 53),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (1140, 57),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "' ",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1140, 68),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1140, 72),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/*\nif [[ -n \"$(ls -A ",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1141, 34),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1141, 38),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/config/)\" ]]; then\n  chown --no-dereference ",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 41),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "user",
                           position: (1142, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "':",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 55),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "group",
                           position: (1142, 59),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "' ",
                      },
                      Raw {
                       content: "'",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1142, 70),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "statePath",
                           position: (1142, 74),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "'/config/*\nfi\n",
                      },
                     ],
                     position: (1136, 36),
                    },
                   ),
                  ],
                  target: String {
                   parts: [
                    Raw {
                     content: "+",
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (1145, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "writeShellScript",
                          position: (1145, 21),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "gitlab-pre-start-full-privileges",
                         },
                        ],
                        position: (1145, 38),
                       },
                       Variable {
                        identifier: "preStartFullPrivileges",
                        position: (1145, 73),
                       },
                      ],
                     },
                    },
                   ],
                   position: (1145, 12),
                  },
                  position: (1135, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1147, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1147, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "writeShellScript",
                      position: (1147, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab-config",
                     },
                    ],
                    position: (1147, 43),
                   },
                   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 ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1153, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1153, 23),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1153, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/VERSION ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1153, 63),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1153, 67),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/VERSION\nrm -rf ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1154, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1154, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/db/*\nrm -f ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1155, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1155, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/lib\nfind ",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1156, 19),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1156, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/' -maxdepth 1 -mindepth 1 -type d -execdir rm -rf {} \\;\ncp -rf --no-preserve=mode ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1157, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1157, 43),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1157, 52),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/config.dist/* ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1157, 89),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1157, 93),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config\ncp -rf --no-preserve=mode ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1158, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1158, 43),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1158, 52),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/gitlab/db/* ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1158, 80),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1158, 84),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/db\nln -sf ",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "extraGitlabRb",
                       position: (1159, 20),
                      },
                     },
                     Raw {
                      content: " ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1159, 37),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1159, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/initializers/extra-gitlab.rb\n\n",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1161, 13),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1161, 17),
                         },
                         Raw {
                          content: "gitlab-shell",
                          position: (1161, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/install\n\n",
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (1163, 13),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1163, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "smtp",
                            position: (1163, 32),
                           },
                           Raw {
                            content: "enable",
                            position: (1163, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "install -m u=rw ",
                          },
                          Expression {
                           expression: Variable {
                            identifier: "smtpSettings",
                            position: (1164, 33),
                           },
                          },
                          Raw {
                           content: " ",
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1164, 49),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "statePath",
                               position: (1164, 53),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/config/initializers/smtp_settings.rb\n",
                          },
                          Expression {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "optionalString",
                             position: (1165, 17),
                            },
                            arguments: [
                             BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (1165, 33),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "smtp",
                                   position: (1165, 37),
                                  },
                                  Raw {
                                   content: "passwordFile",
                                   position: (1165, 42),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               Variable {
                                identifier: "null",
                                position: (1165, 58),
                               },
                              ],
                              position: (1165, 55),
                             },
                             String {
                              parts: [
                               Raw {
                                content: "replace-secret '@smtpPassword@' ",
                               },
                               Raw {
                                content: "'",
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1166, 54),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "smtp",
                                    position: (1166, 58),
                                   },
                                   Raw {
                                    content: "passwordFile",
                                    position: (1166, 63),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "' ",
                               },
                               Raw {
                                content: "'",
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1166, 81),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "statePath",
                                    position: (1166, 85),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/config/initializers/smtp_settings.rb'\n",
                               },
                              ],
                              position: (1165, 64),
                             },
                            ],
                           },
                          },
                          Raw {
                           content: "\n",
                          },
                         ],
                         position: (1163, 44),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\n\n(\n  umask u=rwx,g=,o=\n\n  openssl rand -hex 32 > ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1173, 38),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1173, 42),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/gitlab_shell_secret\n\n  rm -f ",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1175, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1175, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/database.yml'\n\n  ",
                     },
                     Expression {
                      expression: IfThenElse {
                       predicate: BinaryOperation {
                        operator: NotEqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1177, 18),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "databasePasswordFile",
                             position: (1177, 22),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (1177, 46),
                         },
                        ],
                        position: (1177, 43),
                       },
                       then: String {
                        parts: [
                         Raw {
                          content: "db_password=\"$(<",
                         },
                         Raw {
                          content: "'",
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1178, 36),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "databasePasswordFile",
                              position: (1178, 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 <",
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1186, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "writeText",
                               position: (1186, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "database.yml",
                              },
                             ],
                             position: (1186, 38),
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (1186, 54),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "toJSON",
                                 position: (1186, 63),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "databaseConfig",
                               position: (1186, 70),
                              },
                             ],
                            },
                           ],
                          },
                         },
                         Raw {
                          content: " \\\n   '.production.password = $ENV.db_password' \\\n   >",
                         },
                         Raw {
                          content: "'",
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1188, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "statePath",
                              position: (1188, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/config/database.yml'\n",
                         },
                        ],
                        position: (1177, 56),
                       },
                       else_: String {
                        parts: [
                         Raw {
                          content: "jq <",
                         },
                         Expression {
                          expression: FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1191, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "writeText",
                               position: (1191, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: "database.yml",
                              },
                             ],
                             position: (1191, 38),
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "builtins",
                               position: (1191, 54),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "toJSON",
                                 position: (1191, 63),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              Variable {
                               identifier: "databaseConfig",
                               position: (1191, 70),
                              },
                             ],
                            },
                           ],
                          },
                         },
                         Raw {
                          content: " \\\n   >",
                         },
                         Raw {
                          content: "'",
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (1192, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "statePath",
                              position: (1192, 28),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/config/database.yml'\n",
                         },
                        ],
                        position: (1190, 20),
                       },
                       position: (1177, 15),
                      },
                     },
                     Raw {
                      content: "\n\n  ",
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "utils",
                         position: (1196, 15),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "genJqSecretsReplacementSnippet",
                           position: (1196, 21),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Variable {
                         identifier: "gitlabConfig",
                         position: (1197, 17),
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1198, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "statePath",
                               position: (1198, 24),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/config/gitlab.yml",
                          },
                         ],
                         position: (1198, 17),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\n\n  rm -f ",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1201, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1201, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/secrets.yml'\n\n  secret=\"$(<",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1203, 27),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1203, 31),
                         },
                         Raw {
                          content: "secretFile",
                          position: (1203, 39),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  db=\"$(<",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1204, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1204, 27),
                         },
                         Raw {
                          content: "dbFile",
                          position: (1204, 35),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  otp=\"$(<",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1205, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1205, 28),
                         },
                         Raw {
                          content: "otpFile",
                          position: (1205, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n  jws=\"$(<",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1206, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secrets",
                          position: (1206, 28),
                         },
                         Raw {
                          content: "jwsFile",
                          position: (1206, 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     > ",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1212, 21),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1212, 25),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/secrets.yml'\n)\n\n# We remove potentially broken links to old gitlab-shell versions\nrm -Rf ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1216, 20),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1216, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/repositories/**/*.git/hooks\n\ngit config --global core.autocrlf \"input\"\n",
                     },
                    ],
                    position: (1147, 59),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1126, 23),
              },
             ),
            ],
            recursive: false,
            position: (1117, 38),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1223, 5),
             },
             Raw {
              content: "services",
              position: (1223, 13),
             },
             Raw {
              content: "gitlab-db-config",
              position: (1223, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1224, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                  },
                 ],
                 position: (1224, 17),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-postgresql.service",
                  },
                 ],
                 position: (1224, 41),
                },
                String {
                 parts: [
                  Raw {
                   content: "postgresql.service",
                  },
                 ],
                 position: (1224, 69),
                },
               ],
               position: (1224, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1225, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1226, 9),
                  },
                 ],
                 position: (1225, 17),
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1227, 12),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1227, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "databaseHost",
                          position: (1227, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [],
                       position: (1227, 42),
                      },
                     ],
                     position: (1227, 39),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "postgresql.service",
                      },
                     ],
                     position: (1227, 46),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optional",
                    position: (1228, 12),
                   },
                   arguments: [
                    Variable {
                     identifier: "databaseActuallyCreateLocally",
                     position: (1228, 21),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitlab-postgresql.service",
                      },
                     ],
                     position: (1228, 51),
                    },
                   ],
                  },
                 ],
                 position: (1228, 9),
                },
               ],
               position: (1227, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1229, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1229, 20),
                },
               ],
               position: (1229, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1230, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1230, 18),
                },
               ],
               position: (1230, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1231, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1232, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "oneshot",
                   },
                  ],
                  position: (1232, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1233, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1233, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1233, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1234, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1234, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1234, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1235, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1235, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1236, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (1236, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1237, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1237, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1237, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1237, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                   },
                  ],
                  position: (1237, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemainAfterExit",
                    position: (1238, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (1238, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1240, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1240, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "writeShellScript",
                      position: (1240, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "gitlab-db-config",
                     },
                    ],
                    position: (1240, 43),
                   },
                   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=\"$(<",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1245, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "initialRootPasswordFile",
                          position: (1245, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "')\"\n",
                     },
                     Expression {
                      expression: Variable {
                       identifier: "gitlab-rake",
                       position: (1246, 13),
                      },
                     },
                     Raw {
                      content: "/bin/gitlab-rake gitlab:db:configure GITLAB_ROOT_PASSWORD=\"$initial_root_password\" \\\n                                                   GITLAB_ROOT_EMAIL=",
                     },
                     Raw {
                      content: "'",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1247, 83),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "initialRootEmail",
                          position: (1247, 87),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "' > /dev/null\n",
                     },
                    ],
                    position: (1240, 62),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1231, 23),
              },
             ),
            ],
            recursive: false,
            position: (1223, 41),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1252, 5),
             },
             Raw {
              content: "services",
              position: (1252, 13),
             },
             Raw {
              content: "gitlab-sidekiq",
              position: (1252, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1253, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                  },
                 ],
                 position: (1254, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "redis-gitlab.service",
                  },
                 ],
                 position: (1255, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "postgresql.service",
                  },
                 ],
                 position: (1256, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                  },
                 ],
                 position: (1257, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-db-config.service",
                  },
                 ],
                 position: (1258, 9),
                },
               ],
               position: (1253, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1260, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                    },
                   ],
                   position: (1261, 9),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1262, 9),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-db-config.service",
                    },
                   ],
                   position: (1263, 9),
                  },
                 ],
                 position: (1260, 17),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (1264, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1264, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (1264, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                     position: (1264, 42),
                    },
                   ],
                   position: (1264, 39),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                    },
                   ],
                   position: (1264, 46),
                  },
                 ],
                },
               ],
               position: (1264, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1265, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1265, 20),
                },
               ],
               position: (1265, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1266, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1266, 18),
                },
               ],
               position: (1266, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1267, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Variable {
                 identifier: "gitlabEnv",
                 position: (1267, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (1267, 35),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1267, 49),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "sidekiq",
                      position: (1267, 53),
                     },
                     Raw {
                      content: "memoryKiller",
                      position: (1267, 61),
                     },
                     Raw {
                      content: "enable",
                      position: (1267, 74),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_MAX_RSS",
                        position: (1268, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1268, 41),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1268, 45),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1268, 53),
                        },
                        Raw {
                         content: "maxMemory",
                         position: (1268, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_GRACE_TIME",
                        position: (1269, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1269, 44),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1269, 48),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1269, 56),
                        },
                        Raw {
                         content: "graceTime",
                         position: (1269, 69),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SIDEKIQ_MEMORY_KILLER_SHUTDOWN_WAIT",
                        position: (1270, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1270, 47),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "sidekiq",
                         position: (1270, 51),
                        },
                        Raw {
                         content: "memoryKiller",
                         position: (1270, 59),
                        },
                        Raw {
                         content: "shutdownWait",
                         position: (1270, 72),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1267, 81),
                  },
                 ],
                },
               ],
               position: (1267, 31),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1272, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1272, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (1273, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1274, 9),
                 },
                 Variable {
                  identifier: "ruby",
                  position: (1275, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1276, 9),
                 },
                 Variable {
                  identifier: "nodejs",
                  position: (1277, 9),
                 },
                 Variable {
                  identifier: "gnupg",
                  position: (1278, 9),
                 },
                 Variable {
                  identifier: "gnutar",
                  position: (1281, 9),
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1282, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1284, 9),
                 },
                ],
                position: (1272, 25),
               },
               position: (1272, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1286, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1287, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                   },
                  ],
                  position: (1287, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1288, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1288, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1288, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1289, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1289, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1289, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1290, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1290, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1291, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "always",
                   },
                  ],
                  position: (1291, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1292, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1292, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1292, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1292, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                   },
                  ],
                  position: (1292, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1293, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1293, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1293, 26),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1293, 35),
                       },
                       Raw {
                        content: "rubyEnv",
                        position: (1293, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/sidekiq -C \"",
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1293, 70),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1293, 74),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1293, 83),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab/config/sidekiq_queues.yml\" -e production",
                   },
                  ],
                  position: (1293, 19),
                 },
                ),
               ],
               recursive: false,
               position: (1286, 23),
              },
             ),
            ],
            recursive: false,
            position: (1252, 39),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1297, 5),
             },
             Raw {
              content: "services",
              position: (1297, 13),
             },
             Raw {
              content: "gitaly",
              position: (1297, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1298, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                  },
                 ],
                 position: (1298, 17),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                  },
                 ],
                 position: (1298, 34),
                },
               ],
               position: (1298, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1299, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                  },
                 ],
                 position: (1299, 19),
                },
               ],
               position: (1299, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1300, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1300, 20),
                },
               ],
               position: (1300, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1301, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1301, 18),
                },
               ],
               position: (1301, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1302, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1302, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "openssh",
                  position: (1303, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1304, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1305, 9),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1306, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "packages",
                     position: (1306, 13),
                    },
                    Raw {
                     content: "gitaly",
                     position: (1306, 22),
                    },
                    Raw {
                     content: "rubyEnv",
                     position: (1306, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1307, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "packages",
                     position: (1307, 13),
                    },
                    Raw {
                     content: "gitaly",
                     position: (1307, 22),
                    },
                    Raw {
                     content: "rubyEnv",
                     position: (1307, 29),
                    },
                    Raw {
                     content: "wrappedRuby",
                     position: (1307, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1308, 9),
                 },
                 Variable {
                  identifier: "bzip2",
                  position: (1309, 9),
                 },
                ],
                position: (1302, 25),
               },
               position: (1302, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1311, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1312, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                   },
                  ],
                  position: (1312, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1313, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1313, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1313, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1314, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1314, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1314, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1315, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1315, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1316, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (1316, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1317, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "gitlabEnv",
                   position: (1317, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "HOME",
                     position: (1317, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1318, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1318, 24),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1318, 28),
                       },
                       Raw {
                        content: "gitaly",
                        position: (1318, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/gitaly ",
                   },
                   Expression {
                    expression: Variable {
                     identifier: "gitalyToml",
                     position: (1318, 58),
                    },
                   },
                  ],
                  position: (1318, 21),
                 },
                ),
               ],
               recursive: false,
               position: (1311, 23),
              },
             ),
            ],
            recursive: false,
            position: (1297, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1322, 5),
             },
             Raw {
              content: "services",
              position: (1322, 13),
             },
             Raw {
              content: "gitlab-pages",
              position: (1322, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (1322, 37),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "gitlabConfig",
               position: (1322, 43),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "production",
                 position: (1322, 56),
                },
                Raw {
                 content: "pages",
                 position: (1322, 67),
                },
                Raw {
                 content: "enabled",
                 position: (1322, 73),
                },
               ],
              },
              default: Some(
               Variable {
                identifier: "false",
                position: (1322, 84),
               },
              ),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (1323, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GitLab static pages daemon",
                  },
                 ],
                 position: (1323, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (1324, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                    },
                   ],
                   position: (1324, 17),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1324, 34),
                  },
                 ],
                 position: (1324, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bindsTo",
                   position: (1325, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1325, 19),
                  },
                 ],
                 position: (1325, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (1326, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                    },
                   ],
                   position: (1326, 20),
                  },
                 ],
                 position: (1326, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "partOf",
                   position: (1327, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                    },
                   ],
                   position: (1327, 18),
                  },
                 ],
                 position: (1327, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1329, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1329, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "unzip",
                      position: (1329, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (1329, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1331, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Type",
                      position: (1332, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "simple",
                     },
                    ],
                    position: (1332, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeoutSec",
                      position: (1333, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "infinity",
                     },
                    ],
                    position: (1333, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Restart",
                      position: (1334, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "on-failure",
                     },
                    ],
                    position: (1334, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "User",
                      position: (1336, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1336, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1336, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Group",
                      position: (1337, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1337, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1337, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (1339, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1339, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1339, 28),
                         },
                         Raw {
                          content: "pages",
                          position: (1339, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/gitlab-pages ",
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArgs",
                        position: (1339, 63),
                       },
                       arguments: [
                        Variable {
                         identifier: "pagesArgs",
                         position: (1339, 79),
                        },
                       ],
                      },
                     },
                    ],
                    position: (1339, 21),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "WorkingDirectory",
                      position: (1340, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "gitlabEnv",
                     position: (1340, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "HOME",
                       position: (1340, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1331, 23),
                },
               ),
              ],
              recursive: false,
              position: (1322, 91),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1344, 5),
             },
             Raw {
              content: "services",
              position: (1344, 13),
             },
             Raw {
              content: "gitlab-workhorse",
              position: (1344, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1345, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                  },
                 ],
                 position: (1345, 17),
                },
               ],
               position: (1345, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1346, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1346, 20),
                },
               ],
               position: (1346, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1347, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1347, 18),
                },
               ],
               position: (1347, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1348, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1348, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "exiftool",
                  position: (1349, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1350, 9),
                 },
                 Variable {
                  identifier: "gnutar",
                  position: (1351, 9),
                 },
                 Variable {
                  identifier: "gzip",
                  position: (1352, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1353, 9),
                 },
                 Variable {
                  identifier: "gitlab-workhorse",
                  position: (1354, 9),
                 },
                ],
                position: (1348, 25),
               },
               position: (1348, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1356, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1357, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "simple",
                   },
                  ],
                  position: (1357, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1358, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1358, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1358, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1359, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1359, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1359, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1360, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1360, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1361, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (1361, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1362, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "gitlabEnv",
                   position: (1362, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "HOME",
                     position: (1362, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1363, 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: (1364, 14),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "packages",
                                    position: (1364, 18),
                                   },
                                   Raw {
                                    content: "gitlab-workhorse",
                                    position: (1364, 27),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/workhorse ",
                               },
                              ],
                              position: (1364, 11),
                             },
                             String {
                              parts: [
                               Raw {
                                content: "-listenUmask 0 ",
                               },
                              ],
                              position: (1365, 13),
                             },
                            ],
                            position: (1365, 11),
                           },
                           String {
                            parts: [
                             Raw {
                              content: "-listenNetwork unix ",
                             },
                            ],
                            position: (1366, 13),
                           },
                          ],
                          position: (1366, 11),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "-listenAddr /run/gitlab/gitlab-workhorse.socket ",
                           },
                          ],
                          position: (1367, 13),
                         },
                        ],
                        position: (1367, 11),
                       },
                       String {
                        parts: [
                         Raw {
                          content: "-authSocket ",
                         },
                         Expression {
                          expression: Variable {
                           identifier: "gitlabSocket",
                           position: (1368, 28),
                          },
                         },
                         Raw {
                          content: " ",
                         },
                        ],
                        position: (1368, 13),
                       },
                      ],
                      position: (1368, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-documentRoot ",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1369, 30),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "packages",
                            position: (1369, 34),
                           },
                           Raw {
                            content: "gitlab",
                            position: (1369, 43),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/share/gitlab/public ",
                       },
                      ],
                      position: (1369, 13),
                     },
                    ],
                    position: (1369, 11),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-secretPath ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1370, 28),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1370, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/.gitlab_workhorse_secret",
                     },
                    ],
                    position: (1370, 13),
                   },
                  ],
                  position: (1370, 11),
                 },
                ),
               ],
               recursive: false,
               position: (1356, 23),
              },
             ),
            ],
            recursive: false,
            position: (1344, 41),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1374, 5),
             },
             Raw {
              content: "services",
              position: (1374, 13),
             },
             Raw {
              content: "gitlab-mailroom",
              position: (1374, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (1374, 40),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "gitlabConfig",
               position: (1374, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "production",
                 position: (1374, 59),
                },
                Raw {
                 content: "incoming_email",
                 position: (1374, 70),
                },
                Raw {
                 content: "enabled",
                 position: (1374, 85),
                },
               ],
              },
              default: Some(
               Variable {
                identifier: "false",
                position: (1374, 96),
               },
              ),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (1375, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "GitLab incoming mail daemon",
                  },
                 ],
                 position: (1375, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (1376, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                    },
                   ],
                   position: (1376, 17),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                    },
                   ],
                   position: (1376, 34),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1376, 57),
                  },
                 ],
                 position: (1376, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "bindsTo",
                   position: (1377, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1377, 19),
                  },
                 ],
                 position: (1377, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (1378, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                    },
                   ],
                   position: (1378, 20),
                  },
                 ],
                 position: (1378, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "partOf",
                   position: (1379, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "gitlab.target",
                    },
                   ],
                   position: (1379, 18),
                  },
                 ],
                 position: (1379, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "environment",
                   position: (1380, 7),
                  },
                 ],
                },
                Variable {
                 identifier: "gitlabEnv",
                 position: (1380, 21),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1381, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Type",
                      position: (1382, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "simple",
                     },
                    ],
                    position: (1382, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeoutSec",
                      position: (1383, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "infinity",
                     },
                    ],
                    position: (1383, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Restart",
                      position: (1384, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "on-failure",
                     },
                    ],
                    position: (1384, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "User",
                      position: (1386, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1386, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "user",
                       position: (1386, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "Group",
                      position: (1387, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1387, 17),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1387, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (1388, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1388, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "packages",
                          position: (1388, 28),
                         },
                         Raw {
                          content: "gitlab",
                          position: (1388, 37),
                         },
                         Raw {
                          content: "rubyEnv",
                          position: (1388, 44),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/bundle exec mail_room -c ",
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1388, 84),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "statePath",
                          position: (1388, 88),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/config/mail_room.yml",
                     },
                    ],
                    position: (1388, 21),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "WorkingDirectory",
                      position: (1389, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "gitlabEnv",
                     position: (1389, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "HOME",
                       position: (1389, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1381, 23),
                },
               ),
              ],
              recursive: false,
              position: (1374, 103),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1393, 5),
             },
             Raw {
              content: "services",
              position: (1393, 13),
             },
             Raw {
              content: "gitlab",
              position: (1393, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1394, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab-workhorse.service",
                  },
                 ],
                 position: (1395, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "network.target",
                  },
                 ],
                 position: (1396, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "redis-gitlab.service",
                  },
                 ],
                 position: (1397, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-config.service",
                  },
                 ],
                 position: (1398, 9),
                },
                String {
                 parts: [
                  Raw {
                   content: "gitlab-db-config.service",
                  },
                 ],
                 position: (1399, 9),
                },
               ],
               position: (1394, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1401, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "redis-gitlab.service",
                    },
                   ],
                   position: (1402, 9),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-config.service",
                    },
                   ],
                   position: (1403, 9),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "gitlab-db-config.service",
                    },
                   ],
                   position: (1404, 9),
                  },
                 ],
                 position: (1401, 17),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (1405, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1405, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "databaseHost",
                        position: (1405, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [],
                     position: (1405, 42),
                    },
                   ],
                   position: (1405, 39),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                    },
                   ],
                   position: (1405, 46),
                  },
                 ],
                },
               ],
               position: (1405, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (1406, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1406, 20),
                },
               ],
               position: (1406, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "partOf",
                 position: (1407, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.target",
                  },
                 ],
                 position: (1407, 18),
                },
               ],
               position: (1407, 16),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1408, 7),
                },
               ],
              },
              Variable {
               identifier: "gitlabEnv",
               position: (1408, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (1409, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "pkgs",
                position: (1409, 19),
               },
               target: List {
                elements: [
                 Variable {
                  identifier: "postgresqlPackage",
                  position: (1410, 9),
                 },
                 Variable {
                  identifier: "git",
                  position: (1411, 9),
                 },
                 Variable {
                  identifier: "openssh",
                  position: (1412, 9),
                 },
                 Variable {
                  identifier: "nodejs",
                  position: (1413, 9),
                 },
                 Variable {
                  identifier: "procps",
                  position: (1414, 9),
                 },
                 Variable {
                  identifier: "gnupg",
                  position: (1415, 9),
                 },
                ],
                position: (1409, 25),
               },
               position: (1409, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1417, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Type",
                    position: (1418, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "notify",
                   },
                  ],
                  position: (1418, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1419, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1419, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1419, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1420, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1420, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1420, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "TimeoutSec",
                    position: (1421, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "infinity",
                   },
                  ],
                  position: (1421, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Restart",
                    position: (1422, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "on-failure",
                   },
                  ],
                  position: (1422, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (1423, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1423, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "packages",
                        position: (1423, 35),
                       },
                       Raw {
                        content: "gitlab",
                        position: (1423, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/share/gitlab",
                   },
                  ],
                  position: (1423, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1424, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "concatStringsSep",
                   position: (1424, 21),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: " ",
                     },
                    ],
                    position: (1424, 38),
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1425, 14),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "packages",
                            position: (1425, 18),
                           },
                           Raw {
                            content: "gitlab",
                            position: (1425, 27),
                           },
                           Raw {
                            content: "rubyEnv",
                            position: (1425, 34),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/puma",
                       },
                      ],
                      position: (1425, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-e production",
                       },
                      ],
                      position: (1426, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-C ",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1427, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "statePath",
                            position: (1427, 21),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/config/puma.rb",
                       },
                      ],
                      position: (1427, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-w ",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1428, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1428, 21),
                           },
                           Raw {
                            content: "workers",
                            position: (1428, 26),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      position: (1428, 11),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "-t ",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1429, 17),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1429, 21),
                           },
                           Raw {
                            content: "threadsMin",
                            position: (1429, 26),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: ":",
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1429, 40),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "puma",
                            position: (1429, 44),
                           },
                           Raw {
                            content: "threadsMax",
                            position: (1429, 49),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      position: (1429, 11),
                     },
                    ],
                    position: (1424, 42),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1417, 23),
              },
             ),
            ],
            recursive: false,
            position: (1393, 31),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (1435, 5),
             },
             Raw {
              content: "services",
              position: (1435, 13),
             },
             Raw {
              content: "gitlab-backup",
              position: (1435, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (1436, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.service",
                  },
                 ],
                 position: (1436, 17),
                },
               ],
               position: (1436, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "bindsTo",
                 position: (1437, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "gitlab.service",
                  },
                 ],
                 position: (1437, 19),
                },
               ],
               position: (1437, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "startAt",
                 position: (1438, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (1438, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "backup",
                  position: (1438, 21),
                 },
                 Raw {
                  content: "startAt",
                  position: (1438, 28),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (1439, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "RAILS_ENV",
                      position: (1440, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "production",
                     },
                    ],
                    position: (1440, 21),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "CRON",
                      position: (1441, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "1",
                     },
                    ],
                    position: (1441, 16),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1439, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalAttrs",
                  position: (1442, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: GreaterThan,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "stringLength",
                      position: (1442, 27),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1442, 40),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "backup",
                          position: (1442, 44),
                         },
                         Raw {
                          content: "skip",
                          position: (1442, 51),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    Int {
                     value: 0,
                     position: (1442, 58),
                    },
                   ],
                   position: (1442, 56),
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "SKIP",
                        position: (1443, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1443, 16),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "backup",
                         position: (1443, 20),
                        },
                        Raw {
                         content: "skip",
                         position: (1443, 27),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1442, 61),
                  },
                 ],
                },
               ],
               position: (1442, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (1445, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (1446, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1446, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "user",
                     position: (1446, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Group",
                    position: (1447, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (1447, 17),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (1447, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ExecStart",
                    position: (1448, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: Variable {
                     identifier: "gitlab-rake",
                     position: (1448, 24),
                    },
                   },
                   Raw {
                    content: "/bin/gitlab-rake gitlab:backup:create",
                   },
                  ],
                  position: (1448, 21),
                 },
                ),
               ],
               recursive: false,
               position: (1445, 23),
              },
             ),
            ],
            recursive: false,
            position: (1435, 38),
           },
          ),
         ],
         recursive: false,
         position: (917, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (1454, 3),
        },
        Raw {
         content: "doc",
         position: (1454, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./gitlab.xml",
        },
       ],
       position: (1454, 14),
      },
     ),
    ],
    recursive: false,
    position: (222, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}