---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "builtins",
   position: (2, 6),
  },
  target: With {
   expression: Variable {
    identifier: "lib",
    position: (3, 6),
   },
   target: LetIn {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "cfg",
         position: (5, 3),
        },
       ],
      },
      PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (5, 9),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "services",
          position: (5, 16),
         },
         Raw {
          content: "gitlab-runner",
          position: (5, 25),
         },
        ],
       },
       default: None,
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "hasDocker",
         position: (6, 3),
        },
       ],
      },
      PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (6, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "virtualisation",
          position: (6, 22),
         },
         Raw {
          content: "docker",
          position: (6, 37),
         },
         Raw {
          content: "enable",
          position: (6, 44),
         },
        ],
       },
       default: None,
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "hashedServices",
         position: (7, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mapAttrs'",
        position: (7, 20),
       },
       arguments: [
        Function {
         argument: Some(
          "name",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "service",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "nameValuePair",
            position: (8, 21),
           },
           arguments: [
            String {
             parts: [
              Expression {
               expression: Variable {
                identifier: "name",
                position: (9, 10),
               },
              },
              Raw {
               content: "_",
               position: (9, 15),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (9, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "networking",
                   position: (9, 25),
                  },
                  Raw {
                   content: "hostName",
                   position: (9, 36),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "_",
               position: (9, 45),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "substring",
                 position: (10, 9),
                },
                arguments: [
                 Int {
                  value: 0,
                  position: (10, 19),
                 },
                 Int {
                  value: 12,
                  position: (10, 21),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "hashString",
                   position: (11, 10),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "md5",
                      position: (11, 22),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "unsafeDiscardStringContext",
                     position: (11, 28),
                    },
                    arguments: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (11, 56),
                      },
                      arguments: [
                       Variable {
                        identifier: "service",
                        position: (11, 63),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                ],
               },
              },
             ],
            },
            Variable {
             identifier: "service",
             position: (12, 7),
            },
           ],
          },
          position: (8, 12),
         },
         position: (8, 6),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (13, 5),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (13, 9),
           },
          ],
         },
         default: None,
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "configPath",
         position: (14, 3),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "$HOME/.gitlab-runner/config.toml",
         position: (14, 17),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "configureScript",
         position: (15, 3),
        },
       ],
      },
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (15, 21),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeShellScriptBin",
           position: (15, 26),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "gitlab-runner-configure",
           position: (15, 47),
          },
         ],
        },
        IfThenElse {
         predicate: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (16, 9),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "configFile",
               position: (16, 13),
              },
             ],
            },
            default: None,
           },
           Variable {
            identifier: "null",
            position: (16, 27),
           },
          ],
          position: (16, 24),
         },
         then: String {
          parts: [
           Raw {
            content: "mkdir -p $(dirname ",
            position: (17, 1),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (17, 28),
            },
           },
           Raw {
            content: ")\ncp ",
            position: (17, 39),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (18, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "configFile",
                position: (18, 16),
               },
              ],
             },
             default: None,
            },
           },
           Raw {
            content: " ",
            position: (18, 27),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (18, 30),
            },
           },
           Raw {
            content: "\n# make config file readable by service\nchown -R --reference=$HOME $(dirname ",
            position: (18, 41),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (20, 46),
            },
           },
           Raw {
            content: ")\n",
            position: (20, 57),
           },
          ],
         },
         else_: String {
          parts: [
           Raw {
            content: "export CONFIG_FILE=",
            position: (22, 1),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (22, 28),
            },
           },
           Raw {
            content: "\n\nmkdir -p $(dirname ",
            position: (22, 39),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (24, 28),
            },
           },
           Raw {
            content: ")\n\n# remove no longer existing services\ngitlab-runner verify --delete\n\n# current and desired state\nNEEDED_SERVICES=$(echo ",
            position: (24, 39),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "concatStringsSep",
              position: (30, 32),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: " ",
                 position: (30, 50),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "attrNames",
                position: (30, 54),
               },
               arguments: [
                Variable {
                 identifier: "hashedServices",
                 position: (30, 64),
                },
               ],
              },
             ],
            },
           },
           Raw {
            content: " | tr \" \" \"\\n\")\nREGISTERED_SERVICES=$(gitlab-runner list 2>&1 | grep 'Executor' | awk '{ print $1 }')\n\n# difference between current and desired state\nNEW_SERVICES=$(grep -vxF -f <(echo \"$REGISTERED_SERVICES\") <(echo \"$NEEDED_SERVICES\") || true)\nOLD_SERVICES=$(grep -vxF -f <(echo \"$NEEDED_SERVICES\") <(echo \"$REGISTERED_SERVICES\") || true)\n\n# register new services\n",
            position: (30, 80),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "concatStringsSep",
              position: (38, 9),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "\n",
                 position: (38, 27),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (38, 32),
               },
               arguments: [
                Function {
                 argument: Some(
                  "name",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "service",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "if echo \"$NEW_SERVICES\" | grep -xq ",
                     position: (39, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "name",
                      position: (39, 46),
                     },
                    },
                    Raw {
                     content: "; then\n  bash -c ",
                     position: (39, 51),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "escapeShellArg",
                       position: (40, 21),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "concatStringsSep",
                         position: (40, 37),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: " \\\n ",
                            position: (40, 55),
                           },
                          ],
                         },
                         BinaryOperation {
                          operator: Concatenation,
                          operands: [
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "set -a && source ",
                                position: (41, 14),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "service",
                                  position: (41, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "registrationConfigFile",
                                    position: (41, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: " &&",
                                position: (41, 64),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "gitlab-runner register",
                                position: (42, 14),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--non-interactive",
                                position: (43, 14),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--name ",
                                position: (44, 14),
                               },
                               Expression {
                                expression: Variable {
                                 identifier: "name",
                                 position: (44, 23),
                                },
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--executor ",
                                position: (45, 14),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "service",
                                  position: (45, 27),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "executor",
                                    position: (45, 35),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--limit ",
                                position: (46, 14),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (46, 24),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "service",
                                    position: (46, 33),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "limit",
                                      position: (46, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--request-concurrency ",
                                position: (47, 14),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (47, 38),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "service",
                                    position: (47, 47),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "requestConcurrency",
                                      position: (47, 55),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "--maximum-timeout ",
                                position: (48, 14),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (48, 34),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "service",
                                    position: (48, 43),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "maximumTimeout",
                                      position: (48, 51),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                            ],
                            position: (40, 64),
                           },
                           BinaryOperation {
                            operator: Concatenation,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "service",
                               position: (49, 16),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "registrationFlags",
                                 position: (49, 24),
                                },
                               ],
                              },
                              default: None,
                             },
                             BinaryOperation {
                              operator: Concatenation,
                              operands: [
                               FunctionApplication {
                                function: Variable {
                                 identifier: "optional",
                                 position: (50, 16),
                                },
                                arguments: [
                                 BinaryOperation {
                                  operator: NotEqualTo,
                                  operands: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "service",
                                     position: (50, 26),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "buildsDir",
                                       position: (50, 34),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   Variable {
                                    identifier: "null",
                                    position: (50, 47),
                                   },
                                  ],
                                  position: (50, 44),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "--builds-dir ",
                                    position: (51, 14),
                                   },
                                   Expression {
                                    expression: PropertyAccess {
                                     expression: Variable {
                                      identifier: "service",
                                      position: (51, 29),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "buildsDir",
                                        position: (51, 37),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   },
                                  ],
                                 },
                                ],
                               },
                               BinaryOperation {
                                operator: Concatenation,
                                operands: [
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "optional",
                                   position: (52, 16),
                                  },
                                  arguments: [
                                   BinaryOperation {
                                    operator: NotEqualTo,
                                    operands: [
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "service",
                                       position: (52, 26),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "cloneUrl",
                                         position: (52, 34),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                     Variable {
                                      identifier: "null",
                                      position: (52, 46),
                                     },
                                    ],
                                    position: (52, 43),
                                   },
                                   String {
                                    parts: [
                                     Raw {
                                      content: "--clone-url ",
                                      position: (53, 14),
                                     },
                                     Expression {
                                      expression: PropertyAccess {
                                       expression: Variable {
                                        identifier: "service",
                                        position: (53, 28),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "cloneUrl",
                                          position: (53, 36),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     },
                                    ],
                                   },
                                  ],
                                 },
                                 BinaryOperation {
                                  operator: Concatenation,
                                  operands: [
                                   FunctionApplication {
                                    function: Variable {
                                     identifier: "optional",
                                     position: (54, 16),
                                    },
                                    arguments: [
                                     BinaryOperation {
                                      operator: NotEqualTo,
                                      operands: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "service",
                                         position: (54, 26),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "preCloneScript",
                                           position: (54, 34),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                       Variable {
                                        identifier: "null",
                                        position: (54, 52),
                                       },
                                      ],
                                      position: (54, 49),
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "--pre-clone-script ",
                                        position: (55, 14),
                                       },
                                       Expression {
                                        expression: PropertyAccess {
                                         expression: Variable {
                                          identifier: "service",
                                          position: (55, 35),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "preCloneScript",
                                            position: (55, 43),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                       },
                                      ],
                                     },
                                    ],
                                   },
                                   BinaryOperation {
                                    operator: Concatenation,
                                    operands: [
                                     FunctionApplication {
                                      function: Variable {
                                       identifier: "optional",
                                       position: (56, 16),
                                      },
                                      arguments: [
                                       BinaryOperation {
                                        operator: NotEqualTo,
                                        operands: [
                                         PropertyAccess {
                                          expression: Variable {
                                           identifier: "service",
                                           position: (56, 26),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "preBuildScript",
                                             position: (56, 34),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                         Variable {
                                          identifier: "null",
                                          position: (56, 52),
                                         },
                                        ],
                                        position: (56, 49),
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "--pre-build-script ",
                                          position: (57, 14),
                                         },
                                         Expression {
                                          expression: PropertyAccess {
                                           expression: Variable {
                                            identifier: "service",
                                            position: (57, 35),
                                           },
                                           attribute_path: AttributePath {
                                            attributes: [
                                             Raw {
                                              content: "preBuildScript",
                                              position: (57, 43),
                                             },
                                            ],
                                           },
                                           default: None,
                                          },
                                         },
                                        ],
                                       },
                                      ],
                                     },
                                     BinaryOperation {
                                      operator: Concatenation,
                                      operands: [
                                       FunctionApplication {
                                        function: Variable {
                                         identifier: "optional",
                                         position: (58, 16),
                                        },
                                        arguments: [
                                         BinaryOperation {
                                          operator: NotEqualTo,
                                          operands: [
                                           PropertyAccess {
                                            expression: Variable {
                                             identifier: "service",
                                             position: (58, 26),
                                            },
                                            attribute_path: AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "postBuildScript",
                                               position: (58, 34),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                           Variable {
                                            identifier: "null",
                                            position: (58, 53),
                                           },
                                          ],
                                          position: (58, 50),
                                         },
                                         String {
                                          parts: [
                                           Raw {
                                            content: "--post-build-script ",
                                            position: (59, 14),
                                           },
                                           Expression {
                                            expression: PropertyAccess {
                                             expression: Variable {
                                              identifier: "service",
                                              position: (59, 36),
                                             },
                                             attribute_path: AttributePath {
                                              attributes: [
                                               Raw {
                                                content: "postBuildScript",
                                                position: (59, 44),
                                               },
                                              ],
                                             },
                                             default: None,
                                            },
                                           },
                                          ],
                                         },
                                        ],
                                       },
                                       BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                         FunctionApplication {
                                          function: Variable {
                                           identifier: "optional",
                                           position: (60, 16),
                                          },
                                          arguments: [
                                           BinaryOperation {
                                            operator: NotEqualTo,
                                            operands: [
                                             PropertyAccess {
                                              expression: Variable {
                                               identifier: "service",
                                               position: (60, 26),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "tagList",
                                                 position: (60, 34),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                             List {
                                              elements: [],
                                              position: (60, 45),
                                             },
                                            ],
                                            position: (60, 42),
                                           },
                                           String {
                                            parts: [
                                             Raw {
                                              content: "--tag-list ",
                                              position: (61, 14),
                                             },
                                             Expression {
                                              expression: FunctionApplication {
                                               function: Variable {
                                                identifier: "concatStringsSep",
                                                position: (61, 27),
                                               },
                                               arguments: [
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: ",",
                                                   position: (61, 45),
                                                  },
                                                 ],
                                                },
                                                PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "service",
                                                  position: (61, 48),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "tagList",
                                                    position: (61, 56),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                               ],
                                              },
                                             },
                                            ],
                                           },
                                          ],
                                         },
                                         BinaryOperation {
                                          operator: Concatenation,
                                          operands: [
                                           FunctionApplication {
                                            function: Variable {
                                             identifier: "optional",
                                             position: (62, 16),
                                            },
                                            arguments: [
                                             PropertyAccess {
                                              expression: Variable {
                                               identifier: "service",
                                               position: (62, 25),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "runUntagged",
                                                 position: (62, 33),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                             String {
                                              parts: [
                                               Raw {
                                                content: "--run-untagged",
                                                position: (63, 14),
                                               },
                                              ],
                                             },
                                            ],
                                           },
                                           BinaryOperation {
                                            operator: Concatenation,
                                            operands: [
                                             FunctionApplication {
                                              function: Variable {
                                               identifier: "optional",
                                               position: (64, 16),
                                              },
                                              arguments: [
                                               PropertyAccess {
                                                expression: Variable {
                                                 identifier: "service",
                                                 position: (64, 25),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "protected",
                                                   position: (64, 33),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               String {
                                                parts: [
                                                 Raw {
                                                  content: "--access-level ref_protected",
                                                  position: (65, 14),
                                                 },
                                                ],
                                               },
                                              ],
                                             },
                                             BinaryOperation {
                                              operator: Concatenation,
                                              operands: [
                                               FunctionApplication {
                                                function: Variable {
                                                 identifier: "optional",
                                                 position: (66, 16),
                                                },
                                                arguments: [
                                                 PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "service",
                                                   position: (66, 25),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "debugTraceDisabled",
                                                     position: (66, 33),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 String {
                                                  parts: [
                                                   Raw {
                                                    content: "--debug-trace-disabled",
                                                    position: (67, 14),
                                                   },
                                                  ],
                                                 },
                                                ],
                                               },
                                               BinaryOperation {
                                                operator: Concatenation,
                                                operands: [
                                                 FunctionApplication {
                                                  function: Variable {
                                                   identifier: "map",
                                                   position: (68, 16),
                                                  },
                                                  arguments: [
                                                   Function {
                                                    argument: Some(
                                                     "e",
                                                    ),
                                                    arguments: FunctionArguments {
                                                     arguments: [],
                                                     ellipsis: false,
                                                    },
                                                    definition: String {
                                                     parts: [
                                                      Raw {
                                                       content: "--env ",
                                                       position: (68, 25),
                                                      },
                                                      Expression {
                                                       expression: FunctionApplication {
                                                        function: Variable {
                                                         identifier: "escapeShellArg",
                                                         position: (68, 33),
                                                        },
                                                        arguments: [
                                                         Variable {
                                                          identifier: "e",
                                                          position: (68, 48),
                                                         },
                                                        ],
                                                       },
                                                      },
                                                     ],
                                                    },
                                                    position: (68, 21),
                                                   },
                                                   FunctionApplication {
                                                    function: Variable {
                                                     identifier: "mapAttrsToList",
                                                     position: (68, 54),
                                                    },
                                                    arguments: [
                                                     Function {
                                                      argument: Some(
                                                       "name",
                                                      ),
                                                      arguments: FunctionArguments {
                                                       arguments: [],
                                                       ellipsis: false,
                                                      },
                                                      definition: Function {
                                                       argument: Some(
                                                        "value",
                                                       ),
                                                       arguments: FunctionArguments {
                                                        arguments: [],
                                                        ellipsis: false,
                                                       },
                                                       definition: String {
                                                        parts: [
                                                         Expression {
                                                          expression: Variable {
                                                           identifier: "name",
                                                           position: (68, 86),
                                                          },
                                                         },
                                                         Raw {
                                                          content: "=",
                                                          position: (68, 91),
                                                         },
                                                         Expression {
                                                          expression: Variable {
                                                           identifier: "value",
                                                           position: (68, 94),
                                                          },
                                                         },
                                                        ],
                                                       },
                                                       position: (68, 76),
                                                      },
                                                      position: (68, 70),
                                                     },
                                                     PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "service",
                                                       position: (68, 103),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "environmentVariables",
                                                         position: (68, 111),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    ],
                                                   },
                                                  ],
                                                 },
                                                 FunctionApplication {
                                                  function: Variable {
                                                   identifier: "optionals",
                                                   position: (69, 16),
                                                  },
                                                  arguments: [
                                                   FunctionApplication {
                                                    function: Variable {
                                                     identifier: "hasPrefix",
                                                     position: (69, 27),
                                                    },
                                                    arguments: [
                                                     String {
                                                      parts: [
                                                       Raw {
                                                        content: "docker",
                                                        position: (69, 38),
                                                       },
                                                      ],
                                                     },
                                                     PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "service",
                                                       position: (69, 46),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "executor",
                                                         position: (69, 54),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    ],
                                                   },
                                                   Assert {
                                                    expression: FunctionApplication {
                                                     function: Variable {
                                                      identifier: "assertMsg",
                                                      position: (71, 17),
                                                     },
                                                     arguments: [
                                                      BinaryOperation {
                                                       operator: NotEqualTo,
                                                       operands: [
                                                        PropertyAccess {
                                                         expression: Variable {
                                                          identifier: "service",
                                                          position: (71, 28),
                                                         },
                                                         attribute_path: AttributePath {
                                                          attributes: [
                                                           Raw {
                                                            content: "dockerImage",
                                                            position: (71, 36),
                                                           },
                                                          ],
                                                         },
                                                         default: None,
                                                        },
                                                        Variable {
                                                         identifier: "null",
                                                         position: (71, 51),
                                                        },
                                                       ],
                                                       position: (71, 48),
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "dockerImage option is required for ",
                                                         position: (72, 20),
                                                        },
                                                        Expression {
                                                         expression: PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "service",
                                                           position: (72, 57),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "executor",
                                                             position: (72, 65),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        },
                                                        Raw {
                                                         content: " executor (",
                                                         position: (72, 74),
                                                        },
                                                        Expression {
                                                         expression: Variable {
                                                          identifier: "name",
                                                          position: (72, 87),
                                                         },
                                                        },
                                                        Raw {
                                                         content: ")",
                                                         position: (72, 92),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                    },
                                                    target: BinaryOperation {
                                                     operator: Concatenation,
                                                     operands: [
                                                      List {
                                                       elements: [
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "--docker-image ",
                                                           position: (73, 18),
                                                          },
                                                          Expression {
                                                           expression: PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "service",
                                                             position: (73, 35),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "dockerImage",
                                                               position: (73, 43),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (73, 15),
                                                      },
                                                      BinaryOperation {
                                                       operator: Concatenation,
                                                       operands: [
                                                        FunctionApplication {
                                                         function: Variable {
                                                          identifier: "optional",
                                                          position: (74, 18),
                                                         },
                                                         arguments: [
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "service",
                                                            position: (74, 27),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "dockerDisableCache",
                                                              position: (74, 35),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                          String {
                                                           parts: [
                                                            Raw {
                                                             content: "--docker-disable-cache",
                                                             position: (75, 16),
                                                            },
                                                           ],
                                                          },
                                                         ],
                                                        },
                                                        BinaryOperation {
                                                         operator: Concatenation,
                                                         operands: [
                                                          FunctionApplication {
                                                           function: Variable {
                                                            identifier: "optional",
                                                            position: (76, 18),
                                                           },
                                                           arguments: [
                                                            PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "service",
                                                              position: (76, 27),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "dockerPrivileged",
                                                                position: (76, 35),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "--docker-privileged",
                                                               position: (77, 16),
                                                              },
                                                             ],
                                                            },
                                                           ],
                                                          },
                                                          BinaryOperation {
                                                           operator: Concatenation,
                                                           operands: [
                                                            FunctionApplication {
                                                             function: Variable {
                                                              identifier: "map",
                                                              position: (78, 18),
                                                             },
                                                             arguments: [
                                                              Function {
                                                               argument: Some(
                                                                "v",
                                                               ),
                                                               arguments: FunctionArguments {
                                                                arguments: [],
                                                                ellipsis: false,
                                                               },
                                                               definition: String {
                                                                parts: [
                                                                 Raw {
                                                                  content: "--docker-volumes ",
                                                                  position: (78, 27),
                                                                 },
                                                                 Expression {
                                                                  expression: FunctionApplication {
                                                                   function: Variable {
                                                                    identifier: "escapeShellArg",
                                                                    position: (78, 46),
                                                                   },
                                                                   arguments: [
                                                                    Variable {
                                                                     identifier: "v",
                                                                     position: (78, 61),
                                                                    },
                                                                   ],
                                                                  },
                                                                 },
                                                                ],
                                                               },
                                                               position: (78, 23),
                                                              },
                                                              PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "service",
                                                                position: (78, 66),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "dockerVolumes",
                                                                  position: (78, 74),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                             ],
                                                            },
                                                            BinaryOperation {
                                                             operator: Concatenation,
                                                             operands: [
                                                              FunctionApplication {
                                                               function: Variable {
                                                                identifier: "map",
                                                                position: (79, 18),
                                                               },
                                                               arguments: [
                                                                Function {
                                                                 argument: Some(
                                                                  "v",
                                                                 ),
                                                                 arguments: FunctionArguments {
                                                                  arguments: [],
                                                                  ellipsis: false,
                                                                 },
                                                                 definition: String {
                                                                  parts: [
                                                                   Raw {
                                                                    content: "--docker-extra-hosts ",
                                                                    position: (79, 27),
                                                                   },
                                                                   Expression {
                                                                    expression: FunctionApplication {
                                                                     function: Variable {
                                                                      identifier: "escapeShellArg",
                                                                      position: (79, 50),
                                                                     },
                                                                     arguments: [
                                                                      Variable {
                                                                       identifier: "v",
                                                                       position: (79, 65),
                                                                      },
                                                                     ],
                                                                    },
                                                                   },
                                                                  ],
                                                                 },
                                                                 position: (79, 23),
                                                                },
                                                                PropertyAccess {
                                                                 expression: Variable {
                                                                  identifier: "service",
                                                                  position: (79, 70),
                                                                 },
                                                                 attribute_path: AttributePath {
                                                                  attributes: [
                                                                   Raw {
                                                                    content: "dockerExtraHosts",
                                                                    position: (79, 78),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                               ],
                                                              },
                                                              BinaryOperation {
                                                               operator: Concatenation,
                                                               operands: [
                                                                FunctionApplication {
                                                                 function: Variable {
                                                                  identifier: "map",
                                                                  position: (80, 18),
                                                                 },
                                                                 arguments: [
                                                                  Function {
                                                                   argument: Some(
                                                                    "v",
                                                                   ),
                                                                   arguments: FunctionArguments {
                                                                    arguments: [],
                                                                    ellipsis: false,
                                                                   },
                                                                   definition: String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "--docker-allowed-images ",
                                                                      position: (80, 27),
                                                                     },
                                                                     Expression {
                                                                      expression: FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "escapeShellArg",
                                                                        position: (80, 53),
                                                                       },
                                                                       arguments: [
                                                                        Variable {
                                                                         identifier: "v",
                                                                         position: (80, 68),
                                                                        },
                                                                       ],
                                                                      },
                                                                     },
                                                                    ],
                                                                   },
                                                                   position: (80, 23),
                                                                  },
                                                                  PropertyAccess {
                                                                   expression: Variable {
                                                                    identifier: "service",
                                                                    position: (80, 73),
                                                                   },
                                                                   attribute_path: AttributePath {
                                                                    attributes: [
                                                                     Raw {
                                                                      content: "dockerAllowedImages",
                                                                      position: (80, 81),
                                                                     },
                                                                    ],
                                                                   },
                                                                   default: None,
                                                                  },
                                                                 ],
                                                                },
                                                                FunctionApplication {
                                                                 function: Variable {
                                                                  identifier: "map",
                                                                  position: (81, 18),
                                                                 },
                                                                 arguments: [
                                                                  Function {
                                                                   argument: Some(
                                                                    "v",
                                                                   ),
                                                                   arguments: FunctionArguments {
                                                                    arguments: [],
                                                                    ellipsis: false,
                                                                   },
                                                                   definition: String {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "--docker-allowed-services ",
                                                                      position: (81, 27),
                                                                     },
                                                                     Expression {
                                                                      expression: FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "escapeShellArg",
                                                                        position: (81, 55),
                                                                       },
                                                                       arguments: [
                                                                        Variable {
                                                                         identifier: "v",
                                                                         position: (81, 70),
                                                                        },
                                                                       ],
                                                                      },
                                                                     },
                                                                    ],
                                                                   },
                                                                   position: (81, 23),
                                                                  },
                                                                  PropertyAccess {
                                                                   expression: Variable {
                                                                    identifier: "service",
                                                                    position: (81, 75),
                                                                   },
                                                                   attribute_path: AttributePath {
                                                                    attributes: [
                                                                     Raw {
                                                                      content: "dockerAllowedServices",
                                                                      position: (81, 83),
                                                                     },
                                                                    ],
                                                                   },
                                                                   default: None,
                                                                  },
                                                                 ],
                                                                },
                                                               ],
                                                               position: (81, 15),
                                                              },
                                                             ],
                                                             position: (80, 15),
                                                            },
                                                           ],
                                                           position: (79, 15),
                                                          },
                                                         ],
                                                         position: (78, 15),
                                                        },
                                                       ],
                                                       position: (76, 15),
                                                      },
                                                     ],
                                                     position: (74, 15),
                                                    },
                                                    position: (70, 15),
                                                   },
                                                  ],
                                                 },
                                                ],
                                                position: (69, 13),
                                               },
                                              ],
                                              position: (68, 13),
                                             },
                                            ],
                                            position: (66, 13),
                                           },
                                          ],
                                          position: (64, 13),
                                         },
                                        ],
                                        position: (62, 13),
                                       },
                                      ],
                                      position: (60, 13),
                                     },
                                    ],
                                    position: (58, 13),
                                   },
                                  ],
                                  position: (56, 13),
                                 },
                                ],
                                position: (54, 13),
                               },
                              ],
                              position: (52, 13),
                             },
                            ],
                            position: (50, 13),
                           },
                          ],
                          position: (49, 13),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: " && sleep 1 || exit 1\nfi\n",
                     position: (83, 14),
                    },
                   ],
                  },
                  position: (38, 54),
                 },
                 position: (38, 48),
                },
                Variable {
                 identifier: "hashedServices",
                 position: (85, 11),
                },
               ],
              },
             ],
            },
           },
           Raw {
            content: "\n\n# unregister old services\nfor NAME in $(echo \"$OLD_SERVICES\")\ndo\n  [ ! -z \"$NAME\" ] && gitlab-runner unregister \\\n    --name \"$NAME\" && sleep 1\ndone\n\n# update global options\nremarshal --if toml --of json ",
            position: (85, 27),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (95, 39),
            },
           },
           Raw {
            content: " \\\n  | jq -cM ",
            position: (95, 50),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "escapeShellArg",
              position: (96, 20),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "concatStringsSep",
                position: (96, 36),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: " | ",
                   position: (96, 54),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: ".check_interval = ",
                     position: (97, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (97, 34),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (97, 41),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "checkInterval",
                           position: (97, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".concurrent = ",
                     position: (98, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (98, 30),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (98, 37),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "concurrent",
                           position: (98, 41),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".sentry_dsn = ",
                     position: (99, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (99, 30),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (99, 37),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "sentryDSN",
                           position: (99, 41),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".listen_address = ",
                     position: (100, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (100, 34),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (100, 41),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "prometheusListenAddress",
                           position: (100, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".session_server.listen_address = ",
                     position: (101, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (101, 49),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (101, 56),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "sessionServer",
                           position: (101, 60),
                          },
                          Raw {
                           content: "listenAddress",
                           position: (101, 74),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".session_server.advertise_address = ",
                     position: (102, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (102, 52),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (102, 59),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "sessionServer",
                           position: (102, 63),
                          },
                          Raw {
                           content: "advertiseAddress",
                           position: (102, 77),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: ".session_server.session_timeout = ",
                     position: (103, 14),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "toJSON",
                       position: (103, 50),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (103, 57),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "sessionServer",
                           position: (103, 61),
                          },
                          Raw {
                           content: "sessionTimeout",
                           position: (103, 75),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "del(.[] | nulls)",
                     position: (104, 14),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "del(.session_server[] | nulls)",
                     position: (105, 14),
                    },
                   ],
                  },
                 ],
                 position: (96, 59),
                },
               ],
              },
             ],
            },
           },
           Raw {
            content: " \\\n  | remarshal --if json --of toml \\\n  | sponge ",
            position: (106, 14),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (108, 20),
            },
           },
           Raw {
            content: "\n\n# make config file readable by service\nchown -R --reference=$HOME $(dirname ",
            position: (108, 31),
           },
           Expression {
            expression: Variable {
             identifier: "configPath",
             position: (111, 46),
            },
           },
           Raw {
            content: ")\n",
            position: (111, 57),
           },
          ],
         },
         position: (16, 5),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "startScript",
         position: (113, 3),
        },
       ],
      },
      FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (113, 17),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeShellScriptBin",
           position: (113, 22),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "gitlab-runner-start",
           position: (113, 43),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "export CONFIG_FILE=",
           position: (114, 1),
          },
          Expression {
           expression: Variable {
            identifier: "configPath",
            position: (114, 26),
           },
          },
          Raw {
           content: "\nexec gitlab-runner run --working-directory $HOME\n",
           position: (114, 37),
          },
         ],
        },
       ],
      },
     ),
    ],
    target: Map {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "options",
          position: (119, 3),
         },
         Raw {
          content: "services",
          position: (119, 11),
         },
         Raw {
          content: "gitlab-runner",
          position: (119, 20),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (120, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkEnableOption",
            position: (120, 14),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Gitlab Runner",
               position: (120, 30),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "configFile",
             position: (121, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (121, 18),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (122, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (122, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "nullOr",
                    position: (122, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (122, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (122, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (123, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (123, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (124, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Configuration file for gitlab-runner.\n\n<option>configFile</option> takes precedence over <option>services</option>.\n<option>checkInterval</option> and <option>concurrent</option> will be ignored too.\n\nThis option is deprecated, please use <option>services</option> instead.\nYou can use <option>registrationConfigFile</option> and\n<option>registrationFlags</option>\nfor settings not covered by this module.\n",
                  position: (125, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (121, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "checkInterval",
             position: (136, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (136, 21),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (137, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (137, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (137, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (138, 7),
                 },
                ],
               },
               Int {
                value: 0,
                position: (138, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (139, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (139, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "with lib; (length (attrNames config.services.gitlab-runner.services)) * 3",
                    position: (139, 36),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (140, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Defines the interval length, in seconds, between new jobs check.\nThe default value is 3;\nif set to 0 or lower, the default value will be used.\nSee <link xlink:href=\"https://docs.gitlab.com/runner/configuration/advanced-configuration.html#how-check_interval-works\">runner documentation</link> for more information.\n",
                  position: (141, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (136, 30),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "concurrent",
             position: (147, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (147, 18),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (148, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (148, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (148, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (149, 7),
                 },
                ],
               },
               Int {
                value: 1,
                position: (149, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (150, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (150, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "config.nix.settings.max-jobs",
                    position: (150, 36),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (151, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Limits how many jobs globally can be run concurrently.\nThe most upper limit of jobs using all defined runners.\n0 does not mean unlimited.\n",
                  position: (152, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (147, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sentryDSN",
             position: (157, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (157, 17),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (158, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (158, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "nullOr",
                    position: (158, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (158, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (159, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (159, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (160, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "https://public:private@host:port/1",
                  position: (160, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (161, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Data Source Name for tracking of all system level errors to Sentry.\n",
                  position: (162, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (157, 26),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "prometheusListenAddress",
             position: (165, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (165, 31),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (166, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (166, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "nullOr",
                    position: (166, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (166, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (166, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (167, 7),
                 },
                ],
               },
               Variable {
                identifier: "null",
                position: (167, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (168, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "localhost:8080",
                  position: (168, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (169, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Address (&lt;host&gt;:&lt;port&gt;) on which the Prometheus metrics HTTP server\nshould be listening.\n",
                  position: (170, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (165, 40),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sessionServer",
             position: (174, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (174, 21),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (175, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (175, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "submodule",
                    position: (175, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (176, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "listenAddress",
                          position: (177, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (177, 27),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (178, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (178, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "nullOr",
                                 position: (178, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (178, 33),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "str",
                                  position: (178, 39),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (179, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (179, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (180, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "0.0.0.0:8093",
                               position: (180, 24),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (181, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "An internal URL to be used for the session server.\n",
                               position: (182, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (177, 36),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "advertiseAddress",
                          position: (185, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (185, 30),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (186, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (186, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "nullOr",
                                 position: (186, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (186, 33),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "str",
                                  position: (186, 39),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (187, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (187, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (188, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "runner-host-name.tld:8093",
                               position: (188, 24),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (189, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "The URL that the Runner will expose to GitLab to be used\nto access the session server.\nFallbacks to <option>listenAddress</option> if not defined.\n",
                               position: (190, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (185, 39),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "sessionTimeout",
                          position: (195, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (195, 28),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (196, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (196, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "int",
                                position: (196, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (197, 13),
                              },
                             ],
                            },
                            Int {
                             value: 1800,
                             position: (197, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (198, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "How long in seconds the session can stay active after\nthe job completes (which will block the job from finishing).\n",
                               position: (199, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (195, 37),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (176, 19),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (175, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (205, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (205, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (206, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (206, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "{\n  listenAddress = \"0.0.0.0:8093\";\n}\n",
                    position: (207, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (211, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "The session server allows the user to interact with jobs\nthat the Runner is responsible for. A good example of this is the\n<link xlink:href=\"https://docs.gitlab.com/ee/ci/interactive_web_terminal/index.html\">interactive web terminal</link>.\n",
                  position: (212, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (174, 30),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "gracefulTermination",
             position: (217, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (217, 27),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (218, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (218, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "bool",
                   position: (218, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (219, 7),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (219, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (220, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Finish all remaining jobs before stopping.\nIf not set gitlab-runner will stop immediatly without waiting\nfor jobs to finish, which will lead to failed builds.\n",
                  position: (221, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (217, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "gracefulTimeout",
             position: (226, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (226, 23),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (227, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (227, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (227, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (228, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "infinity",
                  position: (228, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (229, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "5min 20s",
                  position: (229, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (230, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Time to wait until a graceful shutdown is turned into a forceful one.\n",
                  position: (231, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (226, 32),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "package",
             position: (234, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (234, 15),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (235, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (235, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "package",
                   position: (235, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (236, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (236, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "gitlab-runner",
                   position: (236, 22),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "defaultText",
                  position: (237, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (237, 21),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "pkgs.gitlab-runner",
                    position: (237, 40),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (238, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (238, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "pkgs.gitlab-runner_1_11",
                    position: (238, 36),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (239, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Gitlab Runner package to use.",
                  position: (239, 22),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (234, 24),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "extraPackages",
             position: (241, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (241, 21),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (242, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (242, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (242, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (242, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (242, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (243, 7),
                 },
                ],
               },
               List {
                elements: [],
                position: (243, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (244, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Extra packages to add to PATH for the gitlab-runner process.\n",
                  position: (245, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (241, 30),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (248, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (248, 16),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (249, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "GitLab Runner services.",
                  position: (249, 22),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (250, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (250, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "example",
                  position: (251, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (251, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "{\n  # runner for building in docker via host's nix-daemon\n  # nix store will be readable in runner, might be insecure\n  nix = {\n    # File should contain at least these two variables:\n    # `CI_SERVER_URL`\n    # `REGISTRATION_TOKEN`\n    registrationConfigFile = \"/run/secrets/gitlab-runner-registration\";\n    dockerImage = \"alpine\";\n    dockerVolumes = [\n      \"/nix/store:/nix/store:ro\"\n      \"/nix/var/nix/db:/nix/var/nix/db:ro\"\n      \"/nix/var/nix/daemon-socket:/nix/var/nix/daemon-socket:ro\"\n    ];\n    dockerDisableCache = true;\n    preBuildScript = pkgs.writeScript \"setup-container\" ",
                    position: (252, 1),
                   },
                   Raw {
                    content: "''",
                    position: (267, 65),
                   },
                   Raw {
                    content: "\n      mkdir -p -m 0755 /nix/var/log/nix/drvs\n      mkdir -p -m 0755 /nix/var/nix/gcroots\n      mkdir -p -m 0755 /nix/var/nix/profiles\n      mkdir -p -m 0755 /nix/var/nix/temproots\n      mkdir -p -m 0755 /nix/var/nix/userpool\n      mkdir -p -m 1777 /nix/var/nix/gcroots/per-user\n      mkdir -p -m 1777 /nix/var/nix/profiles/per-user\n      mkdir -p -m 0755 /nix/var/nix/profiles/per-user/root\n      mkdir -p -m 0700 \"$HOME/.nix-defexpr\"\n\n      . ",
                    position: (267, 68),
                   },
                   Raw {
                    content: "$",
                    position: (278, 17),
                   },
                   Raw {
                    content: "{pkgs.nix}/etc/profile.d/nix.sh\n\n      ",
                    position: (278, 20),
                   },
                   Raw {
                    content: "$",
                    position: (280, 15),
                   },
                   Raw {
                    content: "{pkgs.nix}/bin/nix-env -i ",
                    position: (280, 18),
                   },
                   Raw {
                    content: "$",
                    position: (280, 44),
                   },
                   Raw {
                    content: "{concatStringsSep \" \" (with pkgs; [ nix cacert git openssh ])}\n\n      ",
                    position: (280, 47),
                   },
                   Raw {
                    content: "$",
                    position: (282, 15),
                   },
                   Raw {
                    content: "{pkgs.nix}/bin/nix-channel --add https://nixos.org/channels/nixpkgs-unstable\n      ",
                    position: (282, 18),
                   },
                   Raw {
                    content: "$",
                    position: (283, 15),
                   },
                   Raw {
                    content: "{pkgs.nix}/bin/nix-channel --update nixpkgs\n    ",
                    position: (283, 18),
                   },
                   Raw {
                    content: "''",
                    position: (284, 13),
                   },
                   Raw {
                    content: ";\n    environmentVariables = {\n      ENV = \"/etc/profile\";\n      USER = \"root\";\n      NIX_REMOTE = \"daemon\";\n      PATH = \"/nix/var/nix/profiles/default/bin:/nix/var/nix/profiles/default/sbin:/bin:/sbin:/usr/bin:/usr/sbin\";\n      NIX_SSL_CERT_FILE = \"/nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt\";\n    };\n    tagList = [ \"nix\" ];\n  };\n  # runner for building docker images\n  docker-images = {\n    # File should contain at least these two variables:\n    # `CI_SERVER_URL`\n    # `REGISTRATION_TOKEN`\n    registrationConfigFile = \"/run/secrets/gitlab-runner-registration\";\n    dockerImage = \"docker:stable\";\n    dockerVolumes = [\n      \"/var/run/docker.sock:/var/run/docker.sock\"\n    ];\n    tagList = [ \"docker-images\" ];\n  };\n  # runner for executing stuff on host system (very insecure!)\n  # make sure to add required packages (including git!)\n  # to `environment.systemPackages`\n  shell = {\n    # File should contain at least these two variables:\n    # `CI_SERVER_URL`\n    # `REGISTRATION_TOKEN`\n    registrationConfigFile = \"/run/secrets/gitlab-runner-registration\";\n    executor = \"shell\";\n    tagList = [ \"shell\" ];\n  };\n  # runner for everything else\n  default = {\n    # File should contain at least these two variables:\n    # `CI_SERVER_URL`\n    # `REGISTRATION_TOKEN`\n    registrationConfigFile = \"/run/secrets/gitlab-runner-registration\";\n    dockerImage = \"debian:stable\";\n  };\n}\n",
                    position: (284, 16),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (327, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (327, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "attrsOf",
                    position: (327, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (327, 29),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "submodule",
                      position: (327, 35),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "options",
                         position: (328, 9),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "registrationConfigFile",
                            position: (329, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (329, 36),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (330, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (330, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "path",
                                  position: (330, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (331, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Absolute path to a file with environment variables\nused for gitlab-runner registration.\nA list of all supported environment variables can be found in\n<literal>gitlab-runner register --help</literal>.\n\nOnes that you probably want to set is\n\n<literal>CI_SERVER_URL=&lt;CI server URL&gt;</literal>\n\n<literal>REGISTRATION_TOKEN=&lt;registration secret&gt;</literal>\n\nWARNING: make sure to use quoted absolute path,\nor it is going to be copied to Nix Store.\n",
                                 position: (332, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (329, 45),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "registrationFlags",
                            position: (347, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (347, 31),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (348, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (348, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (348, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (348, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (348, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (349, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (349, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (350, 13),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "--docker-helper-image my/gitlab-runner-helper",
                                   position: (350, 26),
                                  },
                                 ],
                                },
                               ],
                               position: (350, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (351, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Extra command-line flags passed to\n<literal>gitlab-runner register</literal>.\nExecute <literal>gitlab-runner register --help</literal>\nfor a list of supported flags.\n",
                                 position: (352, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (347, 40),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "environmentVariables",
                            position: (358, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (358, 34),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (359, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (359, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "attrsOf",
                                   position: (359, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (359, 34),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (359, 40),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (360, 13),
                                },
                               ],
                              },
                              Map {
                               bindings: [],
                               recursive: false,
                               position: (360, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (361, 13),
                                },
                               ],
                              },
                              Map {
                               bindings: [
                                KeyValue(
                                 AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "NAME",
                                    position: (361, 25),
                                   },
                                  ],
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "value",
                                    position: (361, 33),
                                   },
                                  ],
                                 },
                                ),
                               ],
                               recursive: false,
                               position: (361, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (362, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Custom environment variables injected to build environment.\nFor secrets you can use <option>registrationConfigFile</option>\nwith <literal>RUNNER_ENV</literal> variable set.\n",
                                 position: (363, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (358, 43),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "executor",
                            position: (368, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (368, 22),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (369, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (369, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "str",
                                  position: (369, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (370, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "docker",
                                 position: (370, 24),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (371, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Select executor, eg. shell, docker, etc.\nSee <link xlink:href=\"https://docs.gitlab.com/runner/executors/README.html\">runner documentation</link> for more information.\n",
                                 position: (372, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (368, 31),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "buildsDir",
                            position: (376, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (376, 23),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (377, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (377, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (377, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (377, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "path",
                                    position: (377, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (378, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (378, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (379, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "/var/lib/gitlab-runner/builds",
                                 position: (379, 24),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (380, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Absolute path to a directory where builds will be stored\nin context of selected executor (Locally, Docker, SSH).\n",
                                 position: (381, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (376, 32),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "cloneUrl",
                            position: (385, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (385, 22),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (386, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (386, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (386, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (386, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (386, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (387, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (387, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (388, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "http://gitlab.example.local",
                                 position: (388, 24),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (389, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Overwrite the URL for the GitLab instance. Used if the Runner can’t connect to GitLab on the URL GitLab exposes itself.\n",
                                 position: (390, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (385, 31),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerImage",
                            position: (393, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (393, 25),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (394, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (394, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (394, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (394, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (394, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (395, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (395, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (396, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Docker image to be used.\n",
                                 position: (397, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (393, 34),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerVolumes",
                            position: (400, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (400, 27),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (401, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (401, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (401, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (401, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (401, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (402, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (402, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (403, 13),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "/var/run/docker.sock:/var/run/docker.sock",
                                   position: (403, 26),
                                  },
                                 ],
                                },
                               ],
                               position: (403, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (404, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Bind-mount a volume and create it\nif it doesn't exist prior to mounting.\n",
                                 position: (405, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (400, 36),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerDisableCache",
                            position: (409, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (409, 32),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (410, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (410, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (410, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (411, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (411, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (412, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Disable all container caching.\n",
                                 position: (413, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (409, 41),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerPrivileged",
                            position: (416, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (416, 30),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (417, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (417, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (417, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (418, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (418, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (419, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Give extended privileges to container.\n",
                                 position: (420, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (416, 39),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerExtraHosts",
                            position: (423, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (423, 30),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (424, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (424, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (424, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (424, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (424, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (425, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (425, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (426, 13),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "other-host:127.0.0.1",
                                   position: (426, 26),
                                  },
                                 ],
                                },
                               ],
                               position: (426, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (427, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Add a custom host-to-IP mapping.\n",
                                 position: (428, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (423, 39),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerAllowedImages",
                            position: (431, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (431, 33),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (432, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (432, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (432, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (432, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (432, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (433, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (433, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (434, 13),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "ruby:*",
                                   position: (434, 26),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "python:*",
                                   position: (434, 35),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "php:*",
                                   position: (434, 46),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "my.registry.tld:5000/*:*",
                                   position: (434, 54),
                                  },
                                 ],
                                },
                               ],
                               position: (434, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (435, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Whitelist allowed images.\n",
                                 position: (436, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (431, 42),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "dockerAllowedServices",
                            position: (439, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (439, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (440, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (440, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (440, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (440, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (440, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (441, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (441, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (442, 13),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "postgres:9",
                                   position: (442, 26),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "redis:*",
                                   position: (442, 39),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "mysql:*",
                                   position: (442, 49),
                                  },
                                 ],
                                },
                               ],
                               position: (442, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (443, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Whitelist allowed services.\n",
                                 position: (444, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (439, 44),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "preCloneScript",
                            position: (447, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (447, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (448, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (448, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (448, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (448, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "path",
                                    position: (448, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (449, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (449, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (450, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Runner-specific command script executed before code is pulled.\n",
                                 position: (451, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (447, 37),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "preBuildScript",
                            position: (454, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (454, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (455, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (455, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (455, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (455, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "path",
                                    position: (455, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (456, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (456, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (457, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Runner-specific command script executed after code is pulled,\njust before build executes.\n",
                                 position: (458, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (454, 37),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "postBuildScript",
                            position: (462, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (462, 29),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (463, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (463, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "nullOr",
                                   position: (463, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (463, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "path",
                                    position: (463, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (464, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "null",
                               position: (464, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (465, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Runner-specific command script executed after code is pulled\nand just after build executes.\n",
                                 position: (466, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (462, 38),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "tagList",
                            position: (470, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (470, 21),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (471, 13),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (471, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (471, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (471, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (471, 39),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (472, 13),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (472, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (473, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Tag list.\n",
                                 position: (474, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (470, 30),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "runUntagged",
                            position: (477, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (477, 25),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (478, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (478, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (478, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (479, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (479, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (480, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Register to run untagged builds; defaults to\n<literal>true</literal> when <option>tagList</option> is empty.\n",
                                 position: (481, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (477, 34),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "limit",
                            position: (485, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (485, 19),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (486, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (486, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "int",
                                  position: (486, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (487, 13),
                                },
                               ],
                              },
                              Int {
                               value: 0,
                               position: (487, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (488, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Limit how many jobs can be handled concurrently by this service.\n0 (default) simply means don't limit.\n",
                                 position: (489, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (485, 28),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "requestConcurrency",
                            position: (493, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (493, 32),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (494, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (494, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "int",
                                  position: (494, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (495, 13),
                                },
                               ],
                              },
                              Int {
                               value: 0,
                               position: (495, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (496, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Limit number of concurrent requests for new jobs from GitLab.\n",
                                 position: (497, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (493, 41),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "maximumTimeout",
                            position: (500, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (500, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (501, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (501, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "int",
                                  position: (501, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (502, 13),
                                },
                               ],
                              },
                              Int {
                               value: 0,
                               position: (502, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (503, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "What is the maximum timeout (in seconds) that will be set for\njob when using this Runner. 0 (default) simply means don't limit.\n",
                                 position: (504, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (500, 37),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "protected",
                            position: (508, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (508, 23),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (509, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (509, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (509, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (510, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (510, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (511, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "When set to true Runner will only run on pipelines\ntriggered on protected branches.\n",
                                 position: (512, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (508, 32),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "debugTraceDisabled",
                            position: (516, 11),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (516, 32),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (517, 13),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (517, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (517, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (518, 13),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (518, 23),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (519, 13),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "When set to true Runner will disable the possibility of\nusing the <literal>CI_DEBUG_TRACE</literal> feature.\n",
                                 position: (520, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (516, 41),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (328, 19),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (327, 45),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (248, 25),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (119, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "config",
          position: (528, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mkIf",
         position: (528, 12),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (528, 17),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (528, 21),
            },
           ],
          },
          default: None,
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "warnings",
               position: (529, 5),
              },
             ],
            },
            BinaryOperation {
             operator: Concatenation,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (529, 17),
               },
               arguments: [
                Function {
                 argument: Some(
                  "n",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "v",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "services.gitlab-runner.services.",
                     position: (530, 15),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "n",
                      position: (530, 49),
                     },
                    },
                    Raw {
                     content: ".`registrationConfigFile` points to a file in Nix Store. You should use quoted absolute path to prevent this.",
                     position: (530, 51),
                    },
                   ],
                  },
                  position: (530, 11),
                 },
                 position: (530, 8),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "filterAttrs",
                  position: (531, 8),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "n",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: Function {
                    argument: Some(
                     "v",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: FunctionApplication {
                     function: Variable {
                      identifier: "isStorePath",
                      position: (531, 27),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "v",
                        position: (531, 39),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "registrationConfigFile",
                          position: (531, 41),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    position: (531, 24),
                   },
                   position: (531, 21),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (531, 65),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (531, 69),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "optional",
                position: (532, 8),
               },
               arguments: [
                BinaryOperation {
                 operator: NotEqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (532, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "configFile",
                      position: (532, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  Variable {
                   identifier: "null",
                   position: (532, 36),
                  },
                 ],
                 position: (532, 33),
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab-runner.`configFile` is deprecated, please use services.gitlab-runner.`services`.",
                   position: (532, 43),
                  },
                 ],
                },
               ],
              },
             ],
             position: (532, 5),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "environment",
               position: (533, 5),
              },
              Raw {
               content: "systemPackages",
               position: (533, 17),
              },
             ],
            },
            List {
             elements: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (533, 36),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (533, 40),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (533, 34),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (534, 5),
              },
              Raw {
               content: "services",
               position: (534, 13),
              },
              Raw {
               content: "gitlab-runner",
               position: (534, 22),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (535, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Gitlab Runner",
                  position: (535, 22),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "documentation",
                  position: (536, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://docs.gitlab.com/runner/",
                    position: (536, 26),
                   },
                  ],
                 },
                ],
                position: (536, 23),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "after",
                  position: (537, 7),
                 },
                ],
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "network.target",
                      position: (537, 18),
                     },
                    ],
                   },
                  ],
                  position: (537, 15),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optional",
                   position: (538, 12),
                  },
                  arguments: [
                   Variable {
                    identifier: "hasDocker",
                    position: (538, 21),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "docker.service",
                      position: (538, 32),
                     },
                    ],
                   },
                  ],
                 },
                ],
                position: (538, 9),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "requires",
                  position: (539, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (539, 18),
                },
                arguments: [
                 Variable {
                  identifier: "hasDocker",
                  position: (539, 27),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "docker.service",
                    position: (539, 38),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wantedBy",
                  position: (540, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "multi-user.target",
                    position: (540, 21),
                   },
                  ],
                 },
                ],
                position: (540, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (541, 7),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (541, 21),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "networking",
                     position: (541, 28),
                    },
                    Raw {
                     content: "proxy",
                     position: (541, 39),
                    },
                    Raw {
                     content: "envVars",
                     position: (541, 45),
                    },
                   ],
                  },
                  default: None,
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "HOME",
                       position: (542, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/var/lib/gitlab-runner",
                       position: (542, 17),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (541, 56),
                 },
                ],
                position: (541, 53),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (544, 7),
                 },
                ],
               },
               With {
                expression: Variable {
                 identifier: "pkgs",
                 position: (544, 19),
                },
                target: BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  List {
                   elements: [
                    Variable {
                     identifier: "bash",
                     position: (545, 9),
                    },
                    Variable {
                     identifier: "gawk",
                     position: (546, 9),
                    },
                    Variable {
                     identifier: "jq",
                     position: (547, 9),
                    },
                    Variable {
                     identifier: "moreutils",
                     position: (548, 9),
                    },
                    Variable {
                     identifier: "remarshal",
                     position: (549, 9),
                    },
                    Variable {
                     identifier: "util-linux",
                     position: (550, 9),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (551, 9),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "package",
                        position: (551, 13),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (544, 25),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (552, 12),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "extraPackages",
                      position: (552, 16),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (552, 9),
                },
                position: (544, 14),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "reloadIfChanged",
                  position: (553, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (553, 25),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceConfig",
                  position: (554, 7),
                 },
                ],
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "DynamicUser",
                       position: (559, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (559, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "StateDirectory",
                       position: (560, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "gitlab-runner",
                       position: (560, 27),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "SupplementaryGroups",
                       position: (561, 9),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (561, 31),
                     },
                     arguments: [
                      Variable {
                       identifier: "hasDocker",
                       position: (561, 40),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "docker",
                         position: (561, 51),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStartPre",
                       position: (562, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "!",
                       position: (562, 25),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "configureScript",
                        position: (562, 28),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-configure",
                       position: (562, 44),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (563, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "startScript",
                        position: (563, 24),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-start",
                       position: (563, 36),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecReload",
                       position: (564, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "!",
                       position: (564, 23),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "configureScript",
                        position: (564, 26),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-configure",
                       position: (564, 42),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (554, 23),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (565, 12),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (565, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "gracefulTermination",
                       position: (565, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "TimeoutStopSec",
                         position: (566, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (566, 29),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "gracefulTimeout",
                             position: (566, 33),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "KillSignal",
                         position: (567, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "SIGQUIT",
                         position: (567, 23),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "KillMode",
                         position: (568, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "process",
                         position: (568, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (565, 52),
                   },
                  ],
                 },
                ],
                position: (565, 9),
               },
              ),
             ],
             recursive: false,
             position: (534, 38),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "virtualisation",
               position: (572, 5),
              },
              Raw {
               content: "docker",
               position: (572, 20),
              },
              Raw {
               content: "enable",
               position: (572, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (572, 36),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "any",
                position: (573, 7),
               },
               arguments: [
                Function {
                 argument: Some(
                  "s",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "s",
                     position: (573, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "executor",
                       position: (573, 17),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "docker",
                      position: (573, 30),
                     },
                    ],
                   },
                  ],
                  position: (573, 26),
                 },
                 position: (573, 12),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "attrValues",
                  position: (573, 40),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (573, 51),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (573, 55),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (574, 8),
               },
               arguments: [
                Variable {
                 identifier: "true",
                 position: (574, 18),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (528, 28),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "imports",
          position: (576, 3),
         },
        ],
       },
       List {
        elements: [
         FunctionApplication {
          function: Variable {
           identifier: "mkRenamedOptionModule",
           position: (577, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (577, 31),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "gitlab-runner",
                position: (577, 42),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "packages",
                position: (577, 58),
               },
              ],
             },
            ],
            position: (577, 28),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (577, 73),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "gitlab-runner",
                position: (577, 84),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "extraPackages",
                position: (577, 100),
               },
              ],
             },
            ],
            position: (577, 70),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkRemovedOptionModule",
           position: (578, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (578, 31),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "gitlab-runner",
                position: (578, 42),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "configOptions",
                position: (578, 58),
               },
              ],
             },
            ],
            position: (578, 28),
           },
           String {
            parts: [
             Raw {
              content: "Use services.gitlab-runner.services option instead",
              position: (578, 76),
             },
            ],
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkRemovedOptionModule",
           position: (579, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "services",
                position: (579, 31),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "gitlab-runner",
                position: (579, 42),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "workDir",
                position: (579, 58),
               },
              ],
             },
            ],
            position: (579, 28),
           },
           String {
            parts: [
             Raw {
              content: "You should move contents of workDir (if any) to /var/lib/gitlab-runner",
              position: (579, 70),
             },
            ],
           },
          ],
         },
        ],
        position: (576, 13),
       },
      ),
     ],
     recursive: false,
     position: (118, 1),
    },
    position: (4, 1),
   },
   position: (3, 1),
  },
  position: (2, 1),
 },
 position: (1, 1),
}