---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    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: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "cfg",
         position: (5, 3),
        },
       ],
      },
      to: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (5, 9),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "services",
          position: (5, 16),
         },
         Raw {
          content: "gitlab-runner",
          position: (5, 25),
         },
        ],
       },
       default: None,
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "hasDocker",
         position: (6, 3),
        },
       ],
      },
      to: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (6, 15),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "virtualisation",
          position: (6, 22),
         },
         Raw {
          content: "docker",
          position: (6, 37),
         },
         Raw {
          content: "enable",
          position: (6, 44),
         },
        ],
       },
       default: None,
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "hashedServices",
         position: (7, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: Variable {
        identifier: "mapAttrs'",
        position: (7, 20),
       },
       arguments: [
        Parentheses {
         expression: Function {
          argument: Simple {
           identifier: "name",
          },
          definition: Function {
           argument: Simple {
            identifier: "service",
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "nameValuePair",
             position: (8, 21),
            },
            arguments: [
             String {
              parts: [
               Interpolation {
                expression: Variable {
                 identifier: "name",
                 position: (9, 10),
                },
               },
               Raw {
                content: "_",
                position: (9, 15),
               },
               Interpolation {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (9, 18),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "networking",
                    position: (9, 25),
                   },
                   Raw {
                    content: "hostName",
                    position: (9, 36),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "_",
                position: (9, 45),
               },
               Interpolation {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "substring",
                  position: (10, 9),
                 },
                 arguments: [
                  Int {
                   value: 0,
                   position: (10, 19),
                  },
                  Int {
                   value: 12,
                   position: (10, 21),
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "hashString",
                     position: (11, 10),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "md5",
                        position: (11, 22),
                       },
                      ],
                      position: (11, 21),
                     },
                     Parentheses {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "unsafeDiscardStringContext",
                        position: (11, 28),
                       },
                       arguments: [
                        Parentheses {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toJSON",
                           position: (11, 56),
                          },
                          arguments: [
                           Variable {
                            identifier: "service",
                            position: (11, 63),
                           },
                          ],
                         },
                         position: (11, 55),
                        },
                       ],
                      },
                      position: (11, 27),
                     },
                    ],
                   },
                   position: (11, 9),
                  },
                 ],
                },
               },
              ],
              position: (9, 7),
             },
             Variable {
              identifier: "service",
              position: (12, 7),
             },
            ],
           },
           position: (8, 12),
          },
          position: (8, 6),
         },
         position: (8, 5),
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (13, 5),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "services",
            position: (13, 9),
           },
          ],
         },
         default: None,
        },
       ],
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "configPath",
         position: (14, 3),
        },
       ],
      },
      to: String {
       parts: [
        Raw {
         content: "$HOME/.gitlab-runner/config.toml",
         position: (14, 17),
        },
       ],
       position: (14, 16),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "configureScript",
         position: (15, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (15, 21),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "writeShellScriptBin",
           position: (15, 26),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "gitlab-runner-configure",
           position: (15, 47),
          },
         ],
         position: (15, 46),
        },
        Parentheses {
         expression: IfThenElse {
          predicate: Parentheses {
           expression: BinaryOperation {
            operator: NotEqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (16, 9),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "configFile",
                 position: (16, 13),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "null",
              position: (16, 27),
             },
            ],
            position: (16, 24),
           },
           position: (16, 8),
          },
          then: String {
           parts: [
            Raw {
             content: "mkdir -p $(dirname ",
             position: (17, 1),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (17, 28),
             },
            },
            Raw {
             content: ")\ncp ",
             position: (17, 39),
            },
            Interpolation {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (18, 12),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "configFile",
                 position: (18, 16),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: " ",
             position: (18, 27),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (18, 30),
             },
            },
            Raw {
             content: "\n# make config file readable by service\nchown -R --reference=$HOME $(dirname ",
             position: (18, 41),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (20, 46),
             },
            },
            Raw {
             content: ")\n",
             position: (20, 57),
            },
           ],
           position: (16, 38),
          },
          else_: String {
           parts: [
            Raw {
             content: "export CONFIG_FILE=",
             position: (22, 1),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (22, 28),
             },
            },
            Raw {
             content: "\n\nmkdir -p $(dirname ",
             position: (22, 39),
            },
            Interpolation {
             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),
            },
            Interpolation {
             expression: FunctionApplication {
              function: Variable {
               identifier: "concatStringsSep",
               position: (30, 32),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: " ",
                  position: (30, 50),
                 },
                ],
                position: (30, 49),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "attrNames",
                  position: (30, 54),
                 },
                 arguments: [
                  Variable {
                   identifier: "hashedServices",
                   position: (30, 64),
                  },
                 ],
                },
                position: (30, 53),
               },
              ],
             },
            },
            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),
            },
            Interpolation {
             expression: FunctionApplication {
              function: Variable {
               identifier: "concatStringsSep",
               position: (38, 9),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "\n",
                  position: (38, 27),
                 },
                ],
                position: (38, 26),
               },
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrsToList",
                  position: (38, 32),
                 },
                 arguments: [
                  Parentheses {
                   expression: Function {
                    argument: Simple {
                     identifier: "name",
                    },
                    definition: Function {
                     argument: Simple {
                      identifier: "service",
                     },
                     definition: String {
                      parts: [
                       Raw {
                        content: "if echo \"$NEW_SERVICES\" | grep -xq ",
                        position: (39, 1),
                       },
                       Interpolation {
                        expression: Variable {
                         identifier: "name",
                         position: (39, 46),
                        },
                       },
                       Raw {
                        content: "; then\n  bash -c ",
                        position: (39, 51),
                       },
                       Interpolation {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "escapeShellArg",
                          position: (40, 21),
                         },
                         arguments: [
                          Parentheses {
                           expression: FunctionApplication {
                            function: Variable {
                             identifier: "concatStringsSep",
                             position: (40, 37),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: " \\\n ",
                                position: (40, 55),
                               },
                              ],
                              position: (40, 54),
                             },
                             Parentheses {
                              expression: BinaryOperation {
                               operator: Concatenation,
                               operands: [
                                List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "set -a && source ",
                                     position: (41, 14),
                                    },
                                    Interpolation {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "service",
                                       position: (41, 33),
                                      },
                                      attribute_path: AttributePath {
                                       parts: [
                                        Raw {
                                         content: "registrationConfigFile",
                                         position: (41, 41),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: " &&",
                                     position: (41, 64),
                                    },
                                   ],
                                   position: (41, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "gitlab-runner register",
                                     position: (42, 14),
                                    },
                                   ],
                                   position: (42, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--non-interactive",
                                     position: (43, 14),
                                    },
                                   ],
                                   position: (43, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--name ",
                                     position: (44, 14),
                                    },
                                    Interpolation {
                                     expression: Variable {
                                      identifier: "name",
                                      position: (44, 23),
                                     },
                                    },
                                   ],
                                   position: (44, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--executor ",
                                     position: (45, 14),
                                    },
                                    Interpolation {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "service",
                                       position: (45, 27),
                                      },
                                      attribute_path: AttributePath {
                                       parts: [
                                        Raw {
                                         content: "executor",
                                         position: (45, 35),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                   ],
                                   position: (45, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--limit ",
                                     position: (46, 14),
                                    },
                                    Interpolation {
                                     expression: FunctionApplication {
                                      function: Variable {
                                       identifier: "toString",
                                       position: (46, 24),
                                      },
                                      arguments: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "service",
                                         position: (46, 33),
                                        },
                                        attribute_path: AttributePath {
                                         parts: [
                                          Raw {
                                           content: "limit",
                                           position: (46, 41),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      ],
                                     },
                                    },
                                   ],
                                   position: (46, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--request-concurrency ",
                                     position: (47, 14),
                                    },
                                    Interpolation {
                                     expression: FunctionApplication {
                                      function: Variable {
                                       identifier: "toString",
                                       position: (47, 38),
                                      },
                                      arguments: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "service",
                                         position: (47, 47),
                                        },
                                        attribute_path: AttributePath {
                                         parts: [
                                          Raw {
                                           content: "requestConcurrency",
                                           position: (47, 55),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      ],
                                     },
                                    },
                                   ],
                                   position: (47, 13),
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "--maximum-timeout ",
                                     position: (48, 14),
                                    },
                                    Interpolation {
                                     expression: FunctionApplication {
                                      function: Variable {
                                       identifier: "toString",
                                       position: (48, 34),
                                      },
                                      arguments: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "service",
                                         position: (48, 43),
                                        },
                                        attribute_path: AttributePath {
                                         parts: [
                                          Raw {
                                           content: "maximumTimeout",
                                           position: (48, 51),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      ],
                                     },
                                    },
                                   ],
                                   position: (48, 13),
                                  },
                                 ],
                                 position: (40, 64),
                                },
                                BinaryOperation {
                                 operator: Concatenation,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "service",
                                    position: (49, 16),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     Raw {
                                      content: "registrationFlags",
                                      position: (49, 24),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  BinaryOperation {
                                   operator: Concatenation,
                                   operands: [
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optional",
                                      position: (50, 16),
                                     },
                                     arguments: [
                                      Parentheses {
                                       expression: BinaryOperation {
                                        operator: NotEqualTo,
                                        operands: [
                                         PropertyAccess {
                                          expression: Variable {
                                           identifier: "service",
                                           position: (50, 26),
                                          },
                                          attribute_path: AttributePath {
                                           parts: [
                                            Raw {
                                             content: "buildsDir",
                                             position: (50, 34),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                         Variable {
                                          identifier: "null",
                                          position: (50, 47),
                                         },
                                        ],
                                        position: (50, 44),
                                       },
                                       position: (50, 25),
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "--builds-dir ",
                                         position: (51, 14),
                                        },
                                        Interpolation {
                                         expression: PropertyAccess {
                                          expression: Variable {
                                           identifier: "service",
                                           position: (51, 29),
                                          },
                                          attribute_path: AttributePath {
                                           parts: [
                                            Raw {
                                             content: "buildsDir",
                                             position: (51, 37),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                       ],
                                       position: (51, 13),
                                      },
                                     ],
                                    },
                                    BinaryOperation {
                                     operator: Concatenation,
                                     operands: [
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "optional",
                                        position: (52, 16),
                                       },
                                       arguments: [
                                        Parentheses {
                                         expression: BinaryOperation {
                                          operator: NotEqualTo,
                                          operands: [
                                           PropertyAccess {
                                            expression: Variable {
                                             identifier: "service",
                                             position: (52, 26),
                                            },
                                            attribute_path: AttributePath {
                                             parts: [
                                              Raw {
                                               content: "cloneUrl",
                                               position: (52, 34),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                           Variable {
                                            identifier: "null",
                                            position: (52, 46),
                                           },
                                          ],
                                          position: (52, 43),
                                         },
                                         position: (52, 25),
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "--clone-url ",
                                           position: (53, 14),
                                          },
                                          Interpolation {
                                           expression: PropertyAccess {
                                            expression: Variable {
                                             identifier: "service",
                                             position: (53, 28),
                                            },
                                            attribute_path: AttributePath {
                                             parts: [
                                              Raw {
                                               content: "cloneUrl",
                                               position: (53, 36),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                          },
                                         ],
                                         position: (53, 13),
                                        },
                                       ],
                                      },
                                      BinaryOperation {
                                       operator: Concatenation,
                                       operands: [
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "optional",
                                          position: (54, 16),
                                         },
                                         arguments: [
                                          Parentheses {
                                           expression: BinaryOperation {
                                            operator: NotEqualTo,
                                            operands: [
                                             PropertyAccess {
                                              expression: Variable {
                                               identifier: "service",
                                               position: (54, 26),
                                              },
                                              attribute_path: AttributePath {
                                               parts: [
                                                Raw {
                                                 content: "preCloneScript",
                                                 position: (54, 34),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                             Variable {
                                              identifier: "null",
                                              position: (54, 52),
                                             },
                                            ],
                                            position: (54, 49),
                                           },
                                           position: (54, 25),
                                          },
                                          String {
                                           parts: [
                                            Raw {
                                             content: "--pre-clone-script ",
                                             position: (55, 14),
                                            },
                                            Interpolation {
                                             expression: PropertyAccess {
                                              expression: Variable {
                                               identifier: "service",
                                               position: (55, 35),
                                              },
                                              attribute_path: AttributePath {
                                               parts: [
                                                Raw {
                                                 content: "preCloneScript",
                                                 position: (55, 43),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                            },
                                           ],
                                           position: (55, 13),
                                          },
                                         ],
                                        },
                                        BinaryOperation {
                                         operator: Concatenation,
                                         operands: [
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "optional",
                                            position: (56, 16),
                                           },
                                           arguments: [
                                            Parentheses {
                                             expression: BinaryOperation {
                                              operator: NotEqualTo,
                                              operands: [
                                               PropertyAccess {
                                                expression: Variable {
                                                 identifier: "service",
                                                 position: (56, 26),
                                                },
                                                attribute_path: AttributePath {
                                                 parts: [
                                                  Raw {
                                                   content: "preBuildScript",
                                                   position: (56, 34),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               Variable {
                                                identifier: "null",
                                                position: (56, 52),
                                               },
                                              ],
                                              position: (56, 49),
                                             },
                                             position: (56, 25),
                                            },
                                            String {
                                             parts: [
                                              Raw {
                                               content: "--pre-build-script ",
                                               position: (57, 14),
                                              },
                                              Interpolation {
                                               expression: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "service",
                                                 position: (57, 35),
                                                },
                                                attribute_path: AttributePath {
                                                 parts: [
                                                  Raw {
                                                   content: "preBuildScript",
                                                   position: (57, 43),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                              },
                                             ],
                                             position: (57, 13),
                                            },
                                           ],
                                          },
                                          BinaryOperation {
                                           operator: Concatenation,
                                           operands: [
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "optional",
                                              position: (58, 16),
                                             },
                                             arguments: [
                                              Parentheses {
                                               expression: BinaryOperation {
                                                operator: NotEqualTo,
                                                operands: [
                                                 PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "service",
                                                   position: (58, 26),
                                                  },
                                                  attribute_path: AttributePath {
                                                   parts: [
                                                    Raw {
                                                     content: "postBuildScript",
                                                     position: (58, 34),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 Variable {
                                                  identifier: "null",
                                                  position: (58, 53),
                                                 },
                                                ],
                                                position: (58, 50),
                                               },
                                               position: (58, 25),
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "--post-build-script ",
                                                 position: (59, 14),
                                                },
                                                Interpolation {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "service",
                                                   position: (59, 36),
                                                  },
                                                  attribute_path: AttributePath {
                                                   parts: [
                                                    Raw {
                                                     content: "postBuildScript",
                                                     position: (59, 44),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                               ],
                                               position: (59, 13),
                                              },
                                             ],
                                            },
                                            BinaryOperation {
                                             operator: Concatenation,
                                             operands: [
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "optional",
                                                position: (60, 16),
                                               },
                                               arguments: [
                                                Parentheses {
                                                 expression: BinaryOperation {
                                                  operator: NotEqualTo,
                                                  operands: [
                                                   PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "service",
                                                     position: (60, 26),
                                                    },
                                                    attribute_path: AttributePath {
                                                     parts: [
                                                      Raw {
                                                       content: "tagList",
                                                       position: (60, 34),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                   List {
                                                    elements: [],
                                                    position: (60, 45),
                                                   },
                                                  ],
                                                  position: (60, 42),
                                                 },
                                                 position: (60, 25),
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "--tag-list ",
                                                   position: (61, 14),
                                                  },
                                                  Interpolation {
                                                   expression: FunctionApplication {
                                                    function: Variable {
                                                     identifier: "concatStringsSep",
                                                     position: (61, 27),
                                                    },
                                                    arguments: [
                                                     String {
                                                      parts: [
                                                       Raw {
                                                        content: ",",
                                                        position: (61, 45),
                                                       },
                                                      ],
                                                      position: (61, 44),
                                                     },
                                                     PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "service",
                                                       position: (61, 48),
                                                      },
                                                      attribute_path: AttributePath {
                                                       parts: [
                                                        Raw {
                                                         content: "tagList",
                                                         position: (61, 56),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    ],
                                                   },
                                                  },
                                                 ],
                                                 position: (61, 13),
                                                },
                                               ],
                                              },
                                              BinaryOperation {
                                               operator: Concatenation,
                                               operands: [
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "optional",
                                                  position: (62, 16),
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "service",
                                                    position: (62, 25),
                                                   },
                                                   attribute_path: AttributePath {
                                                    parts: [
                                                     Raw {
                                                      content: "runUntagged",
                                                      position: (62, 33),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "--run-untagged",
                                                     position: (63, 14),
                                                    },
                                                   ],
                                                   position: (63, 13),
                                                  },
                                                 ],
                                                },
                                                BinaryOperation {
                                                 operator: Concatenation,
                                                 operands: [
                                                  FunctionApplication {
                                                   function: Variable {
                                                    identifier: "optional",
                                                    position: (64, 16),
                                                   },
                                                   arguments: [
                                                    PropertyAccess {
                                                     expression: Variable {
                                                      identifier: "service",
                                                      position: (64, 25),
                                                     },
                                                     attribute_path: AttributePath {
                                                      parts: [
                                                       Raw {
                                                        content: "protected",
                                                        position: (64, 33),
                                                       },
                                                      ],
                                                     },
                                                     default: None,
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "--access-level ref_protected",
                                                       position: (65, 14),
                                                      },
                                                     ],
                                                     position: (65, 13),
                                                    },
                                                   ],
                                                  },
                                                  BinaryOperation {
                                                   operator: Concatenation,
                                                   operands: [
                                                    FunctionApplication {
                                                     function: Variable {
                                                      identifier: "optional",
                                                      position: (66, 16),
                                                     },
                                                     arguments: [
                                                      PropertyAccess {
                                                       expression: Variable {
                                                        identifier: "service",
                                                        position: (66, 25),
                                                       },
                                                       attribute_path: AttributePath {
                                                        parts: [
                                                         Raw {
                                                          content: "debugTraceDisabled",
                                                          position: (66, 33),
                                                         },
                                                        ],
                                                       },
                                                       default: None,
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "--debug-trace-disabled",
                                                         position: (67, 14),
                                                        },
                                                       ],
                                                       position: (67, 13),
                                                      },
                                                     ],
                                                    },
                                                    BinaryOperation {
                                                     operator: Concatenation,
                                                     operands: [
                                                      FunctionApplication {
                                                       function: Variable {
                                                        identifier: "map",
                                                        position: (68, 16),
                                                       },
                                                       arguments: [
                                                        Parentheses {
                                                         expression: Function {
                                                          argument: Simple {
                                                           identifier: "e",
                                                          },
                                                          definition: String {
                                                           parts: [
                                                            Raw {
                                                             content: "--env ",
                                                             position: (68, 25),
                                                            },
                                                            Interpolation {
                                                             expression: FunctionApplication {
                                                              function: Variable {
                                                               identifier: "escapeShellArg",
                                                               position: (68, 33),
                                                              },
                                                              arguments: [
                                                               Variable {
                                                                identifier: "e",
                                                                position: (68, 48),
                                                               },
                                                              ],
                                                             },
                                                            },
                                                           ],
                                                           position: (68, 24),
                                                          },
                                                          position: (68, 21),
                                                         },
                                                         position: (68, 20),
                                                        },
                                                        Parentheses {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "mapAttrsToList",
                                                           position: (68, 54),
                                                          },
                                                          arguments: [
                                                           Parentheses {
                                                            expression: Function {
                                                             argument: Simple {
                                                              identifier: "name",
                                                             },
                                                             definition: Function {
                                                              argument: Simple {
                                                               identifier: "value",
                                                              },
                                                              definition: String {
                                                               parts: [
                                                                Interpolation {
                                                                 expression: Variable {
                                                                  identifier: "name",
                                                                  position: (68, 86),
                                                                 },
                                                                },
                                                                Raw {
                                                                 content: "=",
                                                                 position: (68, 91),
                                                                },
                                                                Interpolation {
                                                                 expression: Variable {
                                                                  identifier: "value",
                                                                  position: (68, 94),
                                                                 },
                                                                },
                                                               ],
                                                               position: (68, 83),
                                                              },
                                                              position: (68, 76),
                                                             },
                                                             position: (68, 70),
                                                            },
                                                            position: (68, 69),
                                                           },
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "service",
                                                             position: (68, 103),
                                                            },
                                                            attribute_path: AttributePath {
                                                             parts: [
                                                              Raw {
                                                               content: "environmentVariables",
                                                               position: (68, 111),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                         position: (68, 53),
                                                        },
                                                       ],
                                                      },
                                                      FunctionApplication {
                                                       function: Variable {
                                                        identifier: "optionals",
                                                        position: (69, 16),
                                                       },
                                                       arguments: [
                                                        Parentheses {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "hasPrefix",
                                                           position: (69, 27),
                                                          },
                                                          arguments: [
                                                           String {
                                                            parts: [
                                                             Raw {
                                                              content: "docker",
                                                              position: (69, 38),
                                                             },
                                                            ],
                                                            position: (69, 37),
                                                           },
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "service",
                                                             position: (69, 46),
                                                            },
                                                            attribute_path: AttributePath {
                                                             parts: [
                                                              Raw {
                                                               content: "executor",
                                                               position: (69, 54),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                         position: (69, 26),
                                                        },
                                                        Parentheses {
                                                         expression: Assert {
                                                          expression: Parentheses {
                                                           expression: FunctionApplication {
                                                            function: Variable {
                                                             identifier: "assertMsg",
                                                             position: (71, 17),
                                                            },
                                                            arguments: [
                                                             Parentheses {
                                                              expression: BinaryOperation {
                                                               operator: NotEqualTo,
                                                               operands: [
                                                                PropertyAccess {
                                                                 expression: Variable {
                                                                  identifier: "service",
                                                                  position: (71, 28),
                                                                 },
                                                                 attribute_path: AttributePath {
                                                                  parts: [
                                                                   Raw {
                                                                    content: "dockerImage",
                                                                    position: (71, 36),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                                Variable {
                                                                 identifier: "null",
                                                                 position: (71, 51),
                                                                },
                                                               ],
                                                               position: (71, 48),
                                                              },
                                                              position: (71, 27),
                                                             },
                                                             String {
                                                              parts: [
                                                               Raw {
                                                                content: "dockerImage option is required for ",
                                                                position: (72, 20),
                                                               },
                                                               Interpolation {
                                                                expression: PropertyAccess {
                                                                 expression: Variable {
                                                                  identifier: "service",
                                                                  position: (72, 57),
                                                                 },
                                                                 attribute_path: AttributePath {
                                                                  parts: [
                                                                   Raw {
                                                                    content: "executor",
                                                                    position: (72, 65),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                               },
                                                               Raw {
                                                                content: " executor (",
                                                                position: (72, 74),
                                                               },
                                                               Interpolation {
                                                                expression: Variable {
                                                                 identifier: "name",
                                                                 position: (72, 87),
                                                                },
                                                               },
                                                               Raw {
                                                                content: ")",
                                                                position: (72, 92),
                                                               },
                                                              ],
                                                              position: (72, 19),
                                                             },
                                                            ],
                                                           },
                                                           position: (70, 22),
                                                          },
                                                          target: BinaryOperation {
                                                           operator: Concatenation,
                                                           operands: [
                                                            List {
                                                             elements: [
                                                              String {
                                                               parts: [
                                                                Raw {
                                                                 content: "--docker-image ",
                                                                 position: (73, 18),
                                                                },
                                                                Interpolation {
                                                                 expression: PropertyAccess {
                                                                  expression: Variable {
                                                                   identifier: "service",
                                                                   position: (73, 35),
                                                                  },
                                                                  attribute_path: AttributePath {
                                                                   parts: [
                                                                    Raw {
                                                                     content: "dockerImage",
                                                                     position: (73, 43),
                                                                    },
                                                                   ],
                                                                  },
                                                                  default: None,
                                                                 },
                                                                },
                                                               ],
                                                               position: (73, 17),
                                                              },
                                                             ],
                                                             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 {
                                                                  parts: [
                                                                   Raw {
                                                                    content: "dockerDisableCache",
                                                                    position: (74, 35),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                                String {
                                                                 parts: [
                                                                  Raw {
                                                                   content: "--docker-disable-cache",
                                                                   position: (75, 16),
                                                                  },
                                                                 ],
                                                                 position: (75, 15),
                                                                },
                                                               ],
                                                              },
                                                              BinaryOperation {
                                                               operator: Concatenation,
                                                               operands: [
                                                                FunctionApplication {
                                                                 function: Variable {
                                                                  identifier: "optional",
                                                                  position: (76, 18),
                                                                 },
                                                                 arguments: [
                                                                  PropertyAccess {
                                                                   expression: Variable {
                                                                    identifier: "service",
                                                                    position: (76, 27),
                                                                   },
                                                                   attribute_path: AttributePath {
                                                                    parts: [
                                                                     Raw {
                                                                      content: "dockerPrivileged",
                                                                      position: (76, 35),
                                                                     },
                                                                    ],
                                                                   },
                                                                   default: None,
                                                                  },
                                                                  String {
                                                                   parts: [
                                                                    Raw {
                                                                     content: "--docker-privileged",
                                                                     position: (77, 16),
                                                                    },
                                                                   ],
                                                                   position: (77, 15),
                                                                  },
                                                                 ],
                                                                },
                                                                BinaryOperation {
                                                                 operator: Concatenation,
                                                                 operands: [
                                                                  FunctionApplication {
                                                                   function: Variable {
                                                                    identifier: "map",
                                                                    position: (78, 18),
                                                                   },
                                                                   arguments: [
                                                                    Parentheses {
                                                                     expression: Function {
                                                                      argument: Simple {
                                                                       identifier: "v",
                                                                      },
                                                                      definition: String {
                                                                       parts: [
                                                                        Raw {
                                                                         content: "--docker-volumes ",
                                                                         position: (78, 27),
                                                                        },
                                                                        Interpolation {
                                                                         expression: FunctionApplication {
                                                                          function: Variable {
                                                                           identifier: "escapeShellArg",
                                                                           position: (78, 46),
                                                                          },
                                                                          arguments: [
                                                                           Variable {
                                                                            identifier: "v",
                                                                            position: (78, 61),
                                                                           },
                                                                          ],
                                                                         },
                                                                        },
                                                                       ],
                                                                       position: (78, 26),
                                                                      },
                                                                      position: (78, 23),
                                                                     },
                                                                     position: (78, 22),
                                                                    },
                                                                    PropertyAccess {
                                                                     expression: Variable {
                                                                      identifier: "service",
                                                                      position: (78, 66),
                                                                     },
                                                                     attribute_path: AttributePath {
                                                                      parts: [
                                                                       Raw {
                                                                        content: "dockerVolumes",
                                                                        position: (78, 74),
                                                                       },
                                                                      ],
                                                                     },
                                                                     default: None,
                                                                    },
                                                                   ],
                                                                  },
                                                                  BinaryOperation {
                                                                   operator: Concatenation,
                                                                   operands: [
                                                                    FunctionApplication {
                                                                     function: Variable {
                                                                      identifier: "map",
                                                                      position: (79, 18),
                                                                     },
                                                                     arguments: [
                                                                      Parentheses {
                                                                       expression: Function {
                                                                        argument: Simple {
                                                                         identifier: "v",
                                                                        },
                                                                        definition: String {
                                                                         parts: [
                                                                          Raw {
                                                                           content: "--docker-extra-hosts ",
                                                                           position: (79, 27),
                                                                          },
                                                                          Interpolation {
                                                                           expression: FunctionApplication {
                                                                            function: Variable {
                                                                             identifier: "escapeShellArg",
                                                                             position: (79, 50),
                                                                            },
                                                                            arguments: [
                                                                             Variable {
                                                                              identifier: "v",
                                                                              position: (79, 65),
                                                                             },
                                                                            ],
                                                                           },
                                                                          },
                                                                         ],
                                                                         position: (79, 26),
                                                                        },
                                                                        position: (79, 23),
                                                                       },
                                                                       position: (79, 22),
                                                                      },
                                                                      PropertyAccess {
                                                                       expression: Variable {
                                                                        identifier: "service",
                                                                        position: (79, 70),
                                                                       },
                                                                       attribute_path: AttributePath {
                                                                        parts: [
                                                                         Raw {
                                                                          content: "dockerExtraHosts",
                                                                          position: (79, 78),
                                                                         },
                                                                        ],
                                                                       },
                                                                       default: None,
                                                                      },
                                                                     ],
                                                                    },
                                                                    BinaryOperation {
                                                                     operator: Concatenation,
                                                                     operands: [
                                                                      FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "map",
                                                                        position: (80, 18),
                                                                       },
                                                                       arguments: [
                                                                        Parentheses {
                                                                         expression: Function {
                                                                          argument: Simple {
                                                                           identifier: "v",
                                                                          },
                                                                          definition: String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "--docker-allowed-images ",
                                                                             position: (80, 27),
                                                                            },
                                                                            Interpolation {
                                                                             expression: FunctionApplication {
                                                                              function: Variable {
                                                                               identifier: "escapeShellArg",
                                                                               position: (80, 53),
                                                                              },
                                                                              arguments: [
                                                                               Variable {
                                                                                identifier: "v",
                                                                                position: (80, 68),
                                                                               },
                                                                              ],
                                                                             },
                                                                            },
                                                                           ],
                                                                           position: (80, 26),
                                                                          },
                                                                          position: (80, 23),
                                                                         },
                                                                         position: (80, 22),
                                                                        },
                                                                        PropertyAccess {
                                                                         expression: Variable {
                                                                          identifier: "service",
                                                                          position: (80, 73),
                                                                         },
                                                                         attribute_path: AttributePath {
                                                                          parts: [
                                                                           Raw {
                                                                            content: "dockerAllowedImages",
                                                                            position: (80, 81),
                                                                           },
                                                                          ],
                                                                         },
                                                                         default: None,
                                                                        },
                                                                       ],
                                                                      },
                                                                      FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "map",
                                                                        position: (81, 18),
                                                                       },
                                                                       arguments: [
                                                                        Parentheses {
                                                                         expression: Function {
                                                                          argument: Simple {
                                                                           identifier: "v",
                                                                          },
                                                                          definition: String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "--docker-allowed-services ",
                                                                             position: (81, 27),
                                                                            },
                                                                            Interpolation {
                                                                             expression: FunctionApplication {
                                                                              function: Variable {
                                                                               identifier: "escapeShellArg",
                                                                               position: (81, 55),
                                                                              },
                                                                              arguments: [
                                                                               Variable {
                                                                                identifier: "v",
                                                                                position: (81, 70),
                                                                               },
                                                                              ],
                                                                             },
                                                                            },
                                                                           ],
                                                                           position: (81, 26),
                                                                          },
                                                                          position: (81, 23),
                                                                         },
                                                                         position: (81, 22),
                                                                        },
                                                                        PropertyAccess {
                                                                         expression: Variable {
                                                                          identifier: "service",
                                                                          position: (81, 75),
                                                                         },
                                                                         attribute_path: AttributePath {
                                                                          parts: [
                                                                           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, 64),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                     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),
                              },
                              position: (40, 63),
                             },
                            ],
                           },
                           position: (40, 36),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " && sleep 1 || exit 1\nfi\n",
                        position: (83, 14),
                       },
                      ],
                      position: (38, 63),
                     },
                     position: (38, 54),
                    },
                    position: (38, 48),
                   },
                   position: (38, 47),
                  },
                  Variable {
                   identifier: "hashedServices",
                   position: (85, 11),
                  },
                 ],
                },
                position: (38, 31),
               },
              ],
             },
            },
            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),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (95, 39),
             },
            },
            Raw {
             content: " \\\n  | jq -cM ",
             position: (95, 50),
            },
            Interpolation {
             expression: FunctionApplication {
              function: Variable {
               identifier: "escapeShellArg",
               position: (96, 20),
              },
              arguments: [
               Parentheses {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "concatStringsSep",
                  position: (96, 36),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: " | ",
                     position: (96, 54),
                    },
                   ],
                   position: (96, 53),
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: ".check_interval = ",
                       position: (97, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (97, 34),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (97, 41),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "checkInterval",
                             position: (97, 45),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (97, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".concurrent = ",
                       position: (98, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (98, 30),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (98, 37),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "concurrent",
                             position: (98, 41),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (98, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".sentry_dsn = ",
                       position: (99, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (99, 30),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (99, 37),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "sentryDSN",
                             position: (99, 41),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (99, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".listen_address = ",
                       position: (100, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (100, 34),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (100, 41),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "prometheusListenAddress",
                             position: (100, 45),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (100, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".session_server.listen_address = ",
                       position: (101, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (101, 49),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (101, 56),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "sessionServer",
                             position: (101, 60),
                            },
                            Raw {
                             content: "listenAddress",
                             position: (101, 74),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (101, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".session_server.advertise_address = ",
                       position: (102, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (102, 52),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (102, 59),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "sessionServer",
                             position: (102, 63),
                            },
                            Raw {
                             content: "advertiseAddress",
                             position: (102, 77),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (102, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: ".session_server.session_timeout = ",
                       position: (103, 14),
                      },
                      Interpolation {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "toJSON",
                         position: (103, 50),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (103, 57),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "sessionServer",
                             position: (103, 61),
                            },
                            Raw {
                             content: "sessionTimeout",
                             position: (103, 75),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                     ],
                     position: (103, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "del(.[] | nulls)",
                       position: (104, 14),
                      },
                     ],
                     position: (104, 13),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "del(.session_server[] | nulls)",
                       position: (105, 14),
                      },
                     ],
                     position: (105, 13),
                    },
                   ],
                   position: (96, 59),
                  },
                 ],
                },
                position: (96, 35),
               },
              ],
             },
            },
            Raw {
             content: " \\\n  | remarshal --if json --of toml \\\n  | sponge ",
             position: (106, 14),
            },
            Interpolation {
             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),
            },
            Interpolation {
             expression: Variable {
              identifier: "configPath",
              position: (111, 46),
             },
            },
            Raw {
             content: ")\n",
             position: (111, 57),
            },
           ],
           position: (21, 13),
          },
          position: (16, 5),
         },
         position: (15, 72),
        },
       ],
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "startScript",
         position: (113, 3),
        },
       ],
      },
      to: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (113, 17),
        },
        attribute_path: AttributePath {
         parts: [
          Raw {
           content: "writeShellScriptBin",
           position: (113, 22),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "gitlab-runner-start",
           position: (113, 43),
          },
         ],
         position: (113, 42),
        },
        String {
         parts: [
          Raw {
           content: "export CONFIG_FILE=",
           position: (114, 1),
          },
          Interpolation {
           expression: Variable {
            identifier: "configPath",
            position: (114, 26),
           },
          },
          Raw {
           content: "\nexec gitlab-runner run --working-directory $HOME\n",
           position: (114, 37),
          },
         ],
         position: (113, 64),
        },
       ],
      },
     },
    ],
    target: Map {
     bindings: [
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "options",
          position: (119, 3),
         },
         Raw {
          content: "services",
          position: (119, 11),
         },
         Raw {
          content: "gitlab-runner",
          position: (119, 20),
         },
        ],
       },
       to: Map {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "enable",
             position: (120, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkEnableOption",
            position: (120, 14),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Gitlab Runner",
               position: (120, 30),
              },
             ],
             position: (120, 29),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "configFile",
             position: (121, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (121, 18),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (122, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (122, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "nullOr",
                    position: (122, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (122, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "path",
                     position: (122, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (123, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (123, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (124, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (124, 21),
               },
              },
             ],
             recursive: false,
             position: (121, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "checkInterval",
             position: (136, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (136, 21),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (137, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (137, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "int",
                   position: (137, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (138, 7),
                 },
                ],
               },
               to: Int {
                value: 0,
                position: (138, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (139, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (139, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (140, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (140, 21),
               },
              },
             ],
             recursive: false,
             position: (136, 30),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "concurrent",
             position: (147, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (147, 18),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (148, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (148, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "int",
                   position: (148, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (149, 7),
                 },
                ],
               },
               to: Int {
                value: 1,
                position: (149, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (150, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (150, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "config.nix.settings.max-jobs",
                    position: (150, 36),
                   },
                  ],
                  position: (150, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (151, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (151, 21),
               },
              },
             ],
             recursive: false,
             position: (147, 27),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sentryDSN",
             position: (157, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (157, 17),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (158, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (158, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "nullOr",
                    position: (158, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (158, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (159, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (159, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (160, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "https://public:private@host:port/1",
                  position: (160, 18),
                 },
                ],
                position: (160, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (161, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Data Source Name for tracking of all system level errors to Sentry.\n",
                  position: (162, 1),
                 },
                ],
                position: (161, 21),
               },
              },
             ],
             recursive: false,
             position: (157, 26),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "prometheusListenAddress",
             position: (165, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (165, 31),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (166, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (166, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "nullOr",
                    position: (166, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (166, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (166, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (167, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "null",
                position: (167, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (168, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "localhost:8080",
                  position: (168, 18),
                 },
                ],
                position: (168, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (169, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (169, 21),
               },
              },
             ],
             recursive: false,
             position: (165, 40),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "sessionServer",
             position: (174, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (174, 21),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (175, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (175, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "submodule",
                    position: (175, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "options",
                       position: (176, 9),
                      },
                     ],
                    },
                    to: Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "listenAddress",
                          position: (177, 11),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (177, 27),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "type",
                               position: (178, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (178, 20),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "nullOr",
                                 position: (178, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (178, 33),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "str",
                                  position: (178, 39),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "default",
                               position: (179, 13),
                              },
                             ],
                            },
                            to: Variable {
                             identifier: "null",
                             position: (179, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "example",
                               position: (180, 13),
                              },
                             ],
                            },
                            to: String {
                             parts: [
                              Raw {
                               content: "0.0.0.0:8093",
                               position: (180, 24),
                              },
                             ],
                             position: (180, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "description",
                               position: (181, 13),
                              },
                             ],
                            },
                            to: String {
                             parts: [
                              Raw {
                               content: "An internal URL to be used for the session server.\n",
                               position: (182, 1),
                              },
                             ],
                             position: (181, 27),
                            },
                           },
                          ],
                          recursive: false,
                          position: (177, 36),
                         },
                        ],
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "advertiseAddress",
                          position: (185, 11),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (185, 30),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "type",
                               position: (186, 13),
                              },
                             ],
                            },
                            to: FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (186, 20),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "nullOr",
                                 position: (186, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (186, 33),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "str",
                                  position: (186, 39),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "default",
                               position: (187, 13),
                              },
                             ],
                            },
                            to: Variable {
                             identifier: "null",
                             position: (187, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "example",
                               position: (188, 13),
                              },
                             ],
                            },
                            to: String {
                             parts: [
                              Raw {
                               content: "runner-host-name.tld:8093",
                               position: (188, 24),
                              },
                             ],
                             position: (188, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "description",
                               position: (189, 13),
                              },
                             ],
                            },
                            to: 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),
                              },
                             ],
                             position: (189, 27),
                            },
                           },
                          ],
                          recursive: false,
                          position: (185, 39),
                         },
                        ],
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "sessionTimeout",
                          position: (195, 11),
                         },
                        ],
                       },
                       to: FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (195, 28),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "type",
                               position: (196, 13),
                              },
                             ],
                            },
                            to: PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (196, 20),
                             },
                             attribute_path: AttributePath {
                              parts: [
                               Raw {
                                content: "int",
                                position: (196, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "default",
                               position: (197, 13),
                              },
                             ],
                            },
                            to: Int {
                             value: 1800,
                             position: (197, 23),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "description",
                               position: (198, 13),
                              },
                             ],
                            },
                            to: 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),
                              },
                             ],
                             position: (198, 27),
                            },
                           },
                          ],
                          recursive: false,
                          position: (195, 37),
                         },
                        ],
                       },
                      },
                     ],
                     recursive: false,
                     position: (176, 19),
                    },
                   },
                  ],
                  recursive: false,
                  position: (175, 30),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (205, 7),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (205, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (206, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (206, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (211, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (211, 21),
               },
              },
             ],
             recursive: false,
             position: (174, 30),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "gracefulTermination",
             position: (217, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (217, 27),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (218, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (218, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (218, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (219, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "false",
                position: (219, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (220, 7),
                 },
                ],
               },
               to: 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),
                 },
                ],
                position: (220, 21),
               },
              },
             ],
             recursive: false,
             position: (217, 36),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "gracefulTimeout",
             position: (226, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (226, 23),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (227, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (227, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "str",
                   position: (227, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (228, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "infinity",
                  position: (228, 18),
                 },
                ],
                position: (228, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (229, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "5min 20s",
                  position: (229, 18),
                 },
                ],
                position: (229, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (230, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Time to wait until a graceful shutdown is turned into a forceful one.\n",
                  position: (231, 1),
                 },
                ],
                position: (230, 21),
               },
              },
             ],
             recursive: false,
             position: (226, 32),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "package",
             position: (234, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (234, 15),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (235, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (235, 14),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "package",
                   position: (235, 20),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (236, 7),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (236, 17),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "gitlab-runner",
                   position: (236, 22),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "defaultText",
                  position: (237, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (237, 21),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "pkgs.gitlab-runner",
                    position: (237, 40),
                   },
                  ],
                  position: (237, 39),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (238, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "literalExpression",
                 position: (238, 17),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "pkgs.gitlab-runner_1_11",
                    position: (238, 36),
                   },
                  ],
                  position: (238, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (239, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Gitlab Runner package to use.",
                  position: (239, 22),
                 },
                ],
                position: (239, 21),
               },
              },
             ],
             recursive: false,
             position: (234, 24),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "extraPackages",
             position: (241, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (241, 21),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (242, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (242, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "listOf",
                    position: (242, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (242, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "package",
                     position: (242, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (243, 7),
                 },
                ],
               },
               to: List {
                elements: [],
                position: (243, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (244, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Extra packages to add to PATH for the gitlab-runner process.\n",
                  position: (245, 1),
                 },
                ],
                position: (244, 21),
               },
              },
             ],
             recursive: false,
             position: (241, 30),
            },
           ],
          },
         },
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "services",
             position: (248, 5),
            },
           ],
          },
          to: FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (248, 16),
           },
           arguments: [
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (249, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "GitLab Runner services.",
                  position: (249, 22),
                 },
                ],
                position: (249, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "default",
                  position: (250, 7),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (250, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "example",
                  position: (251, 7),
                 },
                ],
               },
               to: 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),
                   },
                  ],
                  position: (251, 35),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "type",
                  position: (327, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (327, 14),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "attrsOf",
                    position: (327, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (327, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "submodule",
                       position: (327, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "options",
                          position: (328, 9),
                         },
                        ],
                       },
                       to: Map {
                        bindings: [
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "registrationConfigFile",
                             position: (329, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (329, 36),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (330, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (330, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "path",
                                   position: (330, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (331, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (331, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (329, 45),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "registrationFlags",
                             position: (347, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (347, 31),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (348, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (348, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (348, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (348, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (348, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (349, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (349, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (350, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "--docker-helper-image my/gitlab-runner-helper",
                                    position: (350, 26),
                                   },
                                  ],
                                  position: (350, 25),
                                 },
                                ],
                                position: (350, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (351, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (351, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (347, 40),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "environmentVariables",
                             position: (358, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (358, 34),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (359, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (359, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "attrsOf",
                                    position: (359, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (359, 34),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (359, 40),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (360, 13),
                                 },
                                ],
                               },
                               to: Map {
                                bindings: [],
                                recursive: false,
                                position: (360, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (361, 13),
                                 },
                                ],
                               },
                               to: Map {
                                bindings: [
                                 Binding {
                                  from: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "NAME",
                                     position: (361, 25),
                                    },
                                   ],
                                  },
                                  to: String {
                                   parts: [
                                    Raw {
                                     content: "value",
                                     position: (361, 33),
                                    },
                                   ],
                                   position: (361, 32),
                                  },
                                 },
                                ],
                                recursive: false,
                                position: (361, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (362, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (362, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (358, 43),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "executor",
                             position: (368, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (368, 22),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (369, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (369, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "str",
                                   position: (369, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (370, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "docker",
                                  position: (370, 24),
                                 },
                                ],
                                position: (370, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (371, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (371, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (368, 31),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "buildsDir",
                             position: (376, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (376, 23),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (377, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (377, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (377, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (377, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "path",
                                     position: (377, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (378, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (378, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (379, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "/var/lib/gitlab-runner/builds",
                                  position: (379, 24),
                                 },
                                ],
                                position: (379, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (380, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (380, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (376, 32),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "cloneUrl",
                             position: (385, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (385, 22),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (386, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (386, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (386, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (386, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (386, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (387, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (387, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (388, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "http://gitlab.example.local",
                                  position: (388, 24),
                                 },
                                ],
                                position: (388, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (389, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (389, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (385, 31),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerImage",
                             position: (393, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (393, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (394, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (394, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (394, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (394, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (394, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (395, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (395, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (396, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Docker image to be used.\n",
                                  position: (397, 1),
                                 },
                                ],
                                position: (396, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (393, 34),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerVolumes",
                             position: (400, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (400, 27),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (401, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (401, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (401, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (401, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (401, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (402, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (402, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (403, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "/var/run/docker.sock:/var/run/docker.sock",
                                    position: (403, 26),
                                   },
                                  ],
                                  position: (403, 25),
                                 },
                                ],
                                position: (403, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (404, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Bind-mount a volume and create it\nif it doesn't exist prior to mounting.\n",
                                  position: (405, 1),
                                 },
                                ],
                                position: (404, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (400, 36),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerDisableCache",
                             position: (409, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (409, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (410, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (410, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "bool",
                                   position: (410, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (411, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "false",
                                position: (411, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (412, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Disable all container caching.\n",
                                  position: (413, 1),
                                 },
                                ],
                                position: (412, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (409, 41),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerPrivileged",
                             position: (416, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (416, 30),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (417, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (417, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "bool",
                                   position: (417, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (418, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "false",
                                position: (418, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (419, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Give extended privileges to container.\n",
                                  position: (420, 1),
                                 },
                                ],
                                position: (419, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (416, 39),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerExtraHosts",
                             position: (423, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (423, 30),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (424, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (424, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (424, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (424, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (424, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (425, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (425, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (426, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "other-host:127.0.0.1",
                                    position: (426, 26),
                                   },
                                  ],
                                  position: (426, 25),
                                 },
                                ],
                                position: (426, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (427, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Add a custom host-to-IP mapping.\n",
                                  position: (428, 1),
                                 },
                                ],
                                position: (427, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (423, 39),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerAllowedImages",
                             position: (431, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (431, 33),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (432, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (432, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (432, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (432, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (432, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (433, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (433, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (434, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "ruby:*",
                                    position: (434, 26),
                                   },
                                  ],
                                  position: (434, 25),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "python:*",
                                    position: (434, 35),
                                   },
                                  ],
                                  position: (434, 34),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "php:*",
                                    position: (434, 46),
                                   },
                                  ],
                                  position: (434, 45),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "my.registry.tld:5000/*:*",
                                    position: (434, 54),
                                   },
                                  ],
                                  position: (434, 53),
                                 },
                                ],
                                position: (434, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (435, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Whitelist allowed images.\n",
                                  position: (436, 1),
                                 },
                                ],
                                position: (435, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (431, 42),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "dockerAllowedServices",
                             position: (439, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (439, 35),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (440, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (440, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (440, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (440, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (440, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (441, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (441, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "example",
                                  position: (442, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "postgres:9",
                                    position: (442, 26),
                                   },
                                  ],
                                  position: (442, 25),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "redis:*",
                                    position: (442, 39),
                                   },
                                  ],
                                  position: (442, 38),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "mysql:*",
                                    position: (442, 49),
                                   },
                                  ],
                                  position: (442, 48),
                                 },
                                ],
                                position: (442, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (443, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Whitelist allowed services.\n",
                                  position: (444, 1),
                                 },
                                ],
                                position: (443, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (439, 44),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "preCloneScript",
                             position: (447, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (447, 28),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (448, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (448, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (448, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (448, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "path",
                                     position: (448, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (449, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (449, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (450, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Runner-specific command script executed before code is pulled.\n",
                                  position: (451, 1),
                                 },
                                ],
                                position: (450, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (447, 37),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "preBuildScript",
                             position: (454, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (454, 28),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (455, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (455, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (455, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (455, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "path",
                                     position: (455, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (456, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (456, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (457, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Runner-specific command script executed after code is pulled,\njust before build executes.\n",
                                  position: (458, 1),
                                 },
                                ],
                                position: (457, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (454, 37),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "postBuildScript",
                             position: (462, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (462, 29),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (463, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (463, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "nullOr",
                                    position: (463, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (463, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "path",
                                     position: (463, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (464, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "null",
                                position: (464, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (465, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Runner-specific command script executed after code is pulled\nand just after build executes.\n",
                                  position: (466, 1),
                                 },
                                ],
                                position: (465, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (462, 38),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "tagList",
                             position: (470, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (470, 21),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (471, 13),
                                 },
                                ],
                               },
                               to: FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (471, 20),
                                 },
                                 attribute_path: AttributePath {
                                  parts: [
                                   Raw {
                                    content: "listOf",
                                    position: (471, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (471, 33),
                                  },
                                  attribute_path: AttributePath {
                                   parts: [
                                    Raw {
                                     content: "str",
                                     position: (471, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (472, 13),
                                 },
                                ],
                               },
                               to: List {
                                elements: [],
                                position: (472, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (473, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Tag list.\n",
                                  position: (474, 1),
                                 },
                                ],
                                position: (473, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (470, 30),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "runUntagged",
                             position: (477, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (477, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (478, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (478, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "bool",
                                   position: (478, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (479, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "false",
                                position: (479, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (480, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (480, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (477, 34),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "limit",
                             position: (485, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (485, 19),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (486, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (486, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "int",
                                   position: (486, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (487, 13),
                                 },
                                ],
                               },
                               to: Int {
                                value: 0,
                                position: (487, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (488, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (488, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (485, 28),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "requestConcurrency",
                             position: (493, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (493, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (494, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (494, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "int",
                                   position: (494, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (495, 13),
                                 },
                                ],
                               },
                               to: Int {
                                value: 0,
                                position: (495, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (496, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "Limit number of concurrent requests for new jobs from GitLab.\n",
                                  position: (497, 1),
                                 },
                                ],
                                position: (496, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (493, 41),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "maximumTimeout",
                             position: (500, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (500, 28),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (501, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (501, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "int",
                                   position: (501, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (502, 13),
                                 },
                                ],
                               },
                               to: Int {
                                value: 0,
                                position: (502, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (503, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (503, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (500, 37),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "protected",
                             position: (508, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (508, 23),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (509, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (509, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "bool",
                                   position: (509, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (510, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "false",
                                position: (510, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (511, 13),
                                 },
                                ],
                               },
                               to: String {
                                parts: [
                                 Raw {
                                  content: "When set to true Runner will only run on pipelines\ntriggered on protected branches.\n",
                                  position: (512, 1),
                                 },
                                ],
                                position: (511, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (508, 32),
                            },
                           ],
                          },
                         },
                         Binding {
                          from: AttributePath {
                           parts: [
                            Raw {
                             content: "debugTraceDisabled",
                             position: (516, 11),
                            },
                           ],
                          },
                          to: FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (516, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "type",
                                  position: (517, 13),
                                 },
                                ],
                               },
                               to: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (517, 20),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "bool",
                                   position: (517, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "default",
                                  position: (518, 13),
                                 },
                                ],
                               },
                               to: Variable {
                                identifier: "false",
                                position: (518, 23),
                               },
                              },
                              Binding {
                               from: AttributePath {
                                parts: [
                                 Raw {
                                  content: "description",
                                  position: (519, 13),
                                 },
                                ],
                               },
                               to: 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),
                                 },
                                ],
                                position: (519, 27),
                               },
                              },
                             ],
                             recursive: false,
                             position: (516, 41),
                            },
                           ],
                          },
                         },
                        ],
                        recursive: false,
                        position: (328, 19),
                       },
                      },
                     ],
                     recursive: false,
                     position: (327, 45),
                    },
                   ],
                  },
                  position: (327, 28),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (248, 25),
            },
           ],
          },
         },
        ],
        recursive: false,
        position: (119, 36),
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "config",
          position: (528, 3),
         },
        ],
       },
       to: FunctionApplication {
        function: Variable {
         identifier: "mkIf",
         position: (528, 12),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (528, 17),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "enable",
             position: (528, 21),
            },
           ],
          },
          default: None,
         },
         Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "warnings",
               position: (529, 5),
              },
             ],
            },
            to: BinaryOperation {
             operator: Concatenation,
             operands: [
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (529, 17),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "n",
                   },
                   definition: Function {
                    argument: Simple {
                     identifier: "v",
                    },
                    definition: String {
                     parts: [
                      Raw {
                       content: "services.gitlab-runner.services.",
                       position: (530, 15),
                      },
                      Interpolation {
                       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, 14),
                    },
                    position: (530, 11),
                   },
                   position: (530, 8),
                  },
                  position: (530, 7),
                 },
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "filterAttrs",
                    position: (531, 8),
                   },
                   arguments: [
                    Parentheses {
                     expression: Function {
                      argument: Simple {
                       identifier: "n",
                      },
                      definition: Function {
                       argument: Simple {
                        identifier: "v",
                       },
                       definition: FunctionApplication {
                        function: Variable {
                         identifier: "isStorePath",
                         position: (531, 27),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "v",
                           position: (531, 39),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "registrationConfigFile",
                             position: (531, 41),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       position: (531, 24),
                      },
                      position: (531, 21),
                     },
                     position: (531, 20),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (531, 65),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "services",
                        position: (531, 69),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  position: (531, 7),
                 },
                ],
               },
               position: (529, 16),
              },
              FunctionApplication {
               function: Variable {
                identifier: "optional",
                position: (532, 8),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (532, 18),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "configFile",
                       position: (532, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (532, 36),
                   },
                  ],
                  position: (532, 33),
                 },
                 position: (532, 17),
                },
                String {
                 parts: [
                  Raw {
                   content: "services.gitlab-runner.`configFile` is deprecated, please use services.gitlab-runner.`services`.",
                   position: (532, 43),
                  },
                 ],
                 position: (532, 42),
                },
               ],
              },
             ],
             position: (532, 5),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "environment",
               position: (533, 5),
              },
              Raw {
               content: "systemPackages",
               position: (533, 17),
              },
             ],
            },
            to: List {
             elements: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (533, 36),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "package",
                  position: (533, 40),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (533, 34),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "systemd",
               position: (534, 5),
              },
              Raw {
               content: "services",
               position: (534, 13),
              },
              Raw {
               content: "gitlab-runner",
               position: (534, 22),
              },
             ],
            },
            to: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (535, 7),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Gitlab Runner",
                  position: (535, 22),
                 },
                ],
                position: (535, 21),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "documentation",
                  position: (536, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "https://docs.gitlab.com/runner/",
                    position: (536, 26),
                   },
                  ],
                  position: (536, 25),
                 },
                ],
                position: (536, 23),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "after",
                  position: (537, 7),
                 },
                ],
               },
               to: BinaryOperation {
                operator: Concatenation,
                operands: [
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "network.target",
                      position: (537, 18),
                     },
                    ],
                    position: (537, 17),
                   },
                  ],
                  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, 31),
                   },
                  ],
                 },
                ],
                position: (538, 9),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "requires",
                  position: (539, 7),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (539, 18),
                },
                arguments: [
                 Variable {
                  identifier: "hasDocker",
                  position: (539, 27),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "docker.service",
                    position: (539, 38),
                   },
                  ],
                  position: (539, 37),
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "wantedBy",
                  position: (540, 7),
                 },
                ],
               },
               to: List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "multi-user.target",
                    position: (540, 21),
                   },
                  ],
                  position: (540, 20),
                 },
                ],
                position: (540, 18),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "environment",
                  position: (541, 7),
                 },
                ],
               },
               to: BinaryOperation {
                operator: Update,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (541, 21),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "networking",
                     position: (541, 28),
                    },
                    Raw {
                     content: "proxy",
                     position: (541, 39),
                    },
                    Raw {
                     content: "envVars",
                     position: (541, 45),
                    },
                   ],
                  },
                  default: None,
                 },
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "HOME",
                       position: (542, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/var/lib/gitlab-runner",
                       position: (542, 17),
                      },
                     ],
                     position: (542, 16),
                    },
                   },
                  ],
                  recursive: false,
                  position: (541, 56),
                 },
                ],
                position: (541, 53),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "path",
                  position: (544, 7),
                 },
                ],
               },
               to: 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 {
                      parts: [
                       Raw {
                        content: "package",
                        position: (551, 13),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (544, 25),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (552, 12),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "extraPackages",
                      position: (552, 16),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (552, 9),
                },
                position: (544, 14),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "reloadIfChanged",
                  position: (553, 7),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (553, 25),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "serviceConfig",
                  position: (554, 7),
                 },
                ],
               },
               to: BinaryOperation {
                operator: Update,
                operands: [
                 Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "DynamicUser",
                       position: (559, 9),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (559, 23),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "StateDirectory",
                       position: (560, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "gitlab-runner",
                       position: (560, 27),
                      },
                     ],
                     position: (560, 26),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "SupplementaryGroups",
                       position: (561, 9),
                      },
                     ],
                    },
                    to: FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (561, 31),
                     },
                     arguments: [
                      Variable {
                       identifier: "hasDocker",
                       position: (561, 40),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "docker",
                         position: (561, 51),
                        },
                       ],
                       position: (561, 50),
                      },
                     ],
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "ExecStartPre",
                       position: (562, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "!",
                       position: (562, 25),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "configureScript",
                        position: (562, 28),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-configure",
                       position: (562, 44),
                      },
                     ],
                     position: (562, 24),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "ExecStart",
                       position: (563, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Interpolation {
                       expression: Variable {
                        identifier: "startScript",
                        position: (563, 24),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-start",
                       position: (563, 36),
                      },
                     ],
                     position: (563, 21),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "ExecReload",
                       position: (564, 9),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "!",
                       position: (564, 23),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "configureScript",
                        position: (564, 26),
                       },
                      },
                      Raw {
                       content: "/bin/gitlab-runner-configure",
                       position: (564, 42),
                      },
                     ],
                     position: (564, 22),
                    },
                   },
                  ],
                  recursive: false,
                  position: (554, 23),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalAttrs",
                   position: (565, 12),
                  },
                  arguments: [
                   Parentheses {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (565, 27),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "gracefulTermination",
                        position: (565, 31),
                       },
                      ],
                     },
                     default: None,
                    },
                    position: (565, 26),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "TimeoutStopSec",
                         position: (566, 9),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Interpolation {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (566, 29),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "gracefulTimeout",
                             position: (566, 33),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                       ],
                       position: (566, 26),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "KillSignal",
                         position: (567, 9),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "SIGQUIT",
                         position: (567, 23),
                        },
                       ],
                       position: (567, 22),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "KillMode",
                         position: (568, 9),
                        },
                       ],
                      },
                      to: String {
                       parts: [
                        Raw {
                         content: "process",
                         position: (568, 21),
                        },
                       ],
                       position: (568, 20),
                      },
                     },
                    ],
                    recursive: false,
                    position: (565, 52),
                   },
                  ],
                 },
                ],
                position: (565, 9),
               },
              },
             ],
             recursive: false,
             position: (534, 38),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "virtualisation",
               position: (572, 5),
              },
              Raw {
               content: "docker",
               position: (572, 20),
              },
              Raw {
               content: "enable",
               position: (572, 27),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (572, 36),
             },
             arguments: [
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "any",
                 position: (573, 7),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "s",
                   },
                   definition: BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "s",
                       position: (573, 15),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "executor",
                         position: (573, 17),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "docker",
                        position: (573, 30),
                       },
                      ],
                      position: (573, 29),
                     },
                    ],
                    position: (573, 26),
                   },
                   position: (573, 12),
                  },
                  position: (573, 11),
                 },
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "attrValues",
                    position: (573, 40),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (573, 51),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "services",
                        position: (573, 55),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  position: (573, 39),
                 },
                ],
               },
               position: (572, 41),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (574, 8),
                },
                arguments: [
                 Variable {
                  identifier: "true",
                  position: (574, 18),
                 },
                ],
               },
               position: (574, 7),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (528, 28),
         },
        ],
       },
      },
      Binding {
       from: AttributePath {
        parts: [
         Raw {
          content: "imports",
          position: (576, 3),
         },
        ],
       },
       to: List {
        elements: [
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "mkRenamedOptionModule",
            position: (577, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "services",
                 position: (577, 31),
                },
               ],
               position: (577, 30),
              },
              String {
               parts: [
                Raw {
                 content: "gitlab-runner",
                 position: (577, 42),
                },
               ],
               position: (577, 41),
              },
              String {
               parts: [
                Raw {
                 content: "packages",
                 position: (577, 58),
                },
               ],
               position: (577, 57),
              },
             ],
             position: (577, 28),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "services",
                 position: (577, 73),
                },
               ],
               position: (577, 72),
              },
              String {
               parts: [
                Raw {
                 content: "gitlab-runner",
                 position: (577, 84),
                },
               ],
               position: (577, 83),
              },
              String {
               parts: [
                Raw {
                 content: "extraPackages",
                 position: (577, 100),
                },
               ],
               position: (577, 99),
              },
             ],
             position: (577, 70),
            },
           ],
          },
          position: (577, 5),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "mkRemovedOptionModule",
            position: (578, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "services",
                 position: (578, 31),
                },
               ],
               position: (578, 30),
              },
              String {
               parts: [
                Raw {
                 content: "gitlab-runner",
                 position: (578, 42),
                },
               ],
               position: (578, 41),
              },
              String {
               parts: [
                Raw {
                 content: "configOptions",
                 position: (578, 58),
                },
               ],
               position: (578, 57),
              },
             ],
             position: (578, 28),
            },
            String {
             parts: [
              Raw {
               content: "Use services.gitlab-runner.services option instead",
               position: (578, 76),
              },
             ],
             position: (578, 75),
            },
           ],
          },
          position: (578, 5),
         },
         Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "mkRemovedOptionModule",
            position: (579, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "services",
                 position: (579, 31),
                },
               ],
               position: (579, 30),
              },
              String {
               parts: [
                Raw {
                 content: "gitlab-runner",
                 position: (579, 42),
                },
               ],
               position: (579, 41),
              },
              String {
               parts: [
                Raw {
                 content: "workDir",
                 position: (579, 58),
                },
               ],
               position: (579, 57),
              },
             ],
             position: (579, 28),
            },
            String {
             parts: [
              Raw {
               content: "You should move contents of workDir (if any) to /var/lib/gitlab-runner",
               position: (579, 70),
              },
             ],
             position: (579, 69),
            },
           ],
          },
          position: (579, 5),
         },
        ],
        position: (576, 13),
       },
      },
     ],
     recursive: false,
     position: (118, 1),
    },
    position: (4, 1),
   },
   position: (3, 1),
  },
  position: (2, 1),
 },
 position: (1, 1),
}