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