---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "archisteamfarm",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "format",
        position: (8, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (8, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "formats",
          position: (8, 17),
         },
         Raw {
          content: "json",
          position: (8, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [],
        recursive: false,
        position: (8, 30),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "asf-config",
        position: (10, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "format",
        position: (10, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generate",
          position: (10, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "ASF.json",
          position: (10, 33),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (10, 44),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "settings",
             position: (10, 48),
            },
           ],
          },
          default: None,
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "UpdateChannel",
               position: (14, 5),
              },
             ],
            },
            Int {
             value: 0,
             position: (14, 21),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "Headless",
               position: (15, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (15, 16),
            },
           ),
          ],
          recursive: false,
          position: (10, 60),
         },
        ],
        position: (10, 57),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "ipc-config",
        position: (18, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "format",
        position: (18, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generate",
          position: (18, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "IPC.config",
          position: (18, 33),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (18, 45),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "ipcSettings",
           position: (18, 49),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBot",
        position: (20, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "n",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "c",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "format",
          position: (21, 5),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "generate",
            position: (21, 12),
           },
          ],
         },
         default: None,
        },
        arguments: [
         String {
          parts: [
           Expression {
            expression: Variable {
             identifier: "n",
             position: (21, 24),
            },
           },
           Raw {
            content: ".json",
            position: (21, 26),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "c",
             position: (21, 34),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (21, 36),
              },
             ],
            },
            default: None,
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "SteamLogin",
                 position: (22, 7),
                },
               ],
              },
              IfThenElse {
               predicate: BinaryOperation {
                operator: EqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "c",
                   position: (22, 23),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "username",
                     position: (22, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [],
                 },
                ],
                position: (22, 34),
               },
               then: Variable {
                identifier: "n",
                position: (22, 45),
               },
               else_: PropertyAccess {
                expression: Variable {
                 identifier: "c",
                 position: (22, 52),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "username",
                   position: (22, 54),
                  },
                 ],
                },
                default: None,
               },
               position: (22, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "SteamPassword",
                 position: (23, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "c",
                position: (23, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "passwordFile",
                  position: (23, 25),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "PasswordFormat",
                 position: (25, 7),
                },
               ],
              },
              Int {
               value: 4,
               position: (25, 24),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "Enabled",
                 position: (26, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "c",
                position: (26, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enabled",
                  position: (26, 19),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (21, 48),
           },
          ],
          position: (21, 45),
         },
        ],
       },
       position: (20, 14),
      },
      position: (20, 11),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (30, 3),
        },
        Raw {
         content: "services",
         position: (30, 11),
        },
        Raw {
         content: "archisteamfarm",
         position: (30, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (31, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (31, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (32, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (32, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (32, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (33, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "If enabled, starts the ArchisSteamFarm service.\nFor configuring the SteamGuard token you will need to use the web-ui, which is enabled by default over on 127.0.0.1:1242.\nYou cannot configure ASF in any way outside of nix, since all the config files get wiped on restart and replaced with the programatically set ones by nix.\n",
                 position: (34, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (38, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (38, 17),
              },
             ),
            ],
            recursive: false,
            position: (31, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "web-ui",
            position: (41, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (41, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (42, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (42, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "submodule",
                   position: (42, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (43, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "enable",
                         position: (44, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkEnableOption",
                        position: (44, 20),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Wheter to start the web-ui. This is the preferred way of configuring things such as the steam guard token",
                           position: (45, 14),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "package",
                         position: (47, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (47, 21),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (48, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (48, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "package",
                               position: (48, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (49, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (49, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "ArchiSteamFarm",
                               position: (49, 28),
                              },
                              Raw {
                               content: "ui",
                               position: (49, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (50, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Web-UI package to use. Contents must be in lib/dist.",
                              position: (51, 16),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (47, 30),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (43, 19),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (42, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (55, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (56, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (56, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "package",
                    position: (57, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (57, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ArchiSteamFarm",
                     position: (57, 24),
                    },
                    Raw {
                     content: "ui",
                     position: (57, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (55, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (59, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (60, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (60, 18),
                 },
                ),
               ],
               recursive: false,
               position: (59, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (62, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The Web-UI hosted on 127.0.0.1:1242.",
                 position: (62, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (41, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "package",
            position: (65, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (65, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (66, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (66, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (66, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (67, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (67, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ArchiSteamFarm",
                  position: (67, 22),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (68, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Package to use. Should always be the latest version, for security reasons, since this module uses very new features and to not get out of sync with the Steam API.",
                 position: (69, 10),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (65, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "dataDir",
            position: (72, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (72, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (73, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (73, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (73, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (74, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/lib/asf",
                 position: (74, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (75, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "        The ASF home directory used to store all data.\nIf left as the default value this directory will automatically be created before the ASF server starts, otherwise the sysadmin is responsible for ensuring the directory exists with appropriate ownership and permissions.",
                 position: (76, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (72, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "settings",
            position: (80, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (80, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (81, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "format",
                position: (81, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (81, 21),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (82, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "        The ASF.json file, all the options are documented <link xlink:href=\"https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#global-config\">here</link>.\n        Do note that `AutoRestart`  and `UpdateChannel` is always to `false`\nrespectively `0` because NixOS takes care of updating everything.\n        `Headless` is also always set to `true` because there is no way to provide inputs via a systemd service.\n        You should try to keep ASF up to date since upstream does not provide support for anything but the latest version and you're exposing yourself to all kinds of issues - as is outlined <link xlink:href=\"https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#updateperiod\">here</link>.\n",
                 position: (83, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (89, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Statistics",
                    position: (90, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (90, 22),
                 },
                ),
               ],
               recursive: false,
               position: (89, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (92, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (92, 17),
              },
             ),
            ],
            recursive: false,
            position: (80, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "ipcSettings",
            position: (95, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (95, 19),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (96, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "format",
                position: (96, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (96, 21),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (97, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Settings to write to IPC.config.\nAll options can be found <link xlink:href=\"https://github.com/JustArchiNET/ArchiSteamFarm/wiki/IPC#custom-configuration\">here</link>.\n",
                 position: (98, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (101, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "Kestrel",
                    position: (102, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Endpoints",
                       position: (103, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "HTTP",
                          position: (104, 13),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "Url",
                             position: (105, 15),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "http://*:1242",
                             position: (105, 22),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (104, 20),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (103, 23),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (102, 19),
                 },
                ),
               ],
               recursive: false,
               position: (101, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (110, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (110, 17),
              },
             ),
            ],
            recursive: false,
            position: (95, 28),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "bots",
            position: (113, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (113, 12),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (114, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (114, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "attrsOf",
                   position: (114, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (114, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "submodule",
                     position: (114, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (115, 9),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "username",
                           position: (116, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (116, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (117, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (117, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (117, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (118, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Name of the user to log in. Default is attribute name.",
                                position: (119, 16),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (120, 13),
                               },
                              ],
                             },
                             String {
                              parts: [],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (116, 31),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "passwordFile",
                           position: (122, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (122, 26),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (123, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (123, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "path",
                                 position: (123, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (124, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Path to a file containig the password. The file must be readable by the <literal>asf</literal> user/group.",
                                position: (125, 16),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (122, 35),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "enabled",
                           position: (127, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (127, 21),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (128, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (128, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "bool",
                                 position: (128, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (129, 13),
                               },
                              ],
                             },
                             Variable {
                              identifier: "true",
                              position: (129, 23),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (130, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Whether to enable the bot on startup.",
                                position: (130, 28),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (127, 30),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "settings",
                           position: (132, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (132, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (133, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (133, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "attrs",
                                 position: (133, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (134, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Additional settings that are documented <link xlink:href=\"https://github.com/JustArchiNET/ArchiSteamFarm/wiki/Configuration#bot-config\">here</link>.",
                                position: (135, 16),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (136, 13),
                               },
                              ],
                             },
                             Map {
                              bindings: [],
                              recursive: false,
                              position: (136, 23),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (132, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (115, 19),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (114, 45),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (140, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Bots name and configuration.\n",
                 position: (141, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (143, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "exampleBot",
                    position: (144, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "username",
                       position: (145, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "alice",
                       position: (145, 23),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "passwordFile",
                       position: (146, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/var/lib/asf/secrets/password",
                       position: (146, 27),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "settings",
                       position: (147, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "SteamParentalCode",
                          position: (147, 24),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "1234",
                          position: (147, 45),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (147, 22),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (144, 22),
                 },
                ),
               ],
               recursive: false,
               position: (143, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (150, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (150, 17),
              },
             ),
            ],
            recursive: false,
            position: (113, 21),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (30, 37),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (154, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (154, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (154, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (154, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (156, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "users",
                 position: (157, 7),
                },
                Raw {
                 content: "asf",
                 position: (157, 13),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "home",
                    position: (158, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (158, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (158, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "isSystemUser",
                    position: (159, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (159, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (160, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "asf",
                    position: (160, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (161, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Archis-Steam-Farm service user",
                    position: (161, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (157, 19),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "groups",
                 position: (163, 7),
                },
                Raw {
                 content: "asf",
                 position: (163, 14),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (163, 20),
              },
             ),
            ],
            recursive: false,
            position: (156, 13),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (166, 5),
             },
             Raw {
              content: "services",
              position: (166, 13),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "asf",
                 position: (167, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (168, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Archis-Steam-Farm Service",
                    position: (168, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (169, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "network.target",
                      position: (169, 20),
                     },
                    ],
                   },
                  ],
                  position: (169, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (170, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "multi-user.target",
                      position: (170, 23),
                     },
                    ],
                   },
                  ],
                  position: (170, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (172, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkMerge",
                   position: (172, 25),
                  },
                  arguments: [
                   List {
                    elements: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkIf",
                       position: (173, 12),
                      },
                      arguments: [
                       BinaryOperation {
                        operator: EqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (173, 18),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "dataDir",
                             position: (173, 22),
                            },
                           ],
                          },
                          default: None,
                         },
                         String {
                          parts: [
                           Raw {
                            content: "/var/lib/asf",
                            position: (173, 34),
                           },
                          ],
                         },
                        ],
                        position: (173, 30),
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "StateDirectory",
                             position: (173, 51),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "asf",
                             position: (173, 69),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (173, 49),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "User",
                           position: (175, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "asf",
                           position: (175, 21),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "Group",
                           position: (176, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "asf",
                           position: (176, 22),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "WorkingDirectory",
                           position: (177, 13),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (177, 32),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "dataDir",
                            position: (177, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "Type",
                           position: (178, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "simple",
                           position: (178, 21),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ExecStart",
                           position: (179, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (180, 18),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "package",
                               position: (180, 22),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/bin/ArchiSteamFarm --path ",
                           position: (180, 30),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (180, 59),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "dataDir",
                               position: (180, 63),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: " --process-required --no-restart --service --no-config-migrate",
                           position: (180, 71),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PrivateTmp",
                           position: (183, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (183, 26),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "LockPersonality",
                           position: (184, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (184, 31),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PrivateDevices",
                           position: (185, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (185, 30),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PrivateIPC",
                           position: (186, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (186, 26),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PrivateMounts",
                           position: (187, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (187, 29),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PrivateUsers",
                           position: (188, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (188, 28),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectClock",
                           position: (189, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (189, 28),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectControlGroups",
                           position: (190, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (190, 36),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectHostname",
                           position: (191, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (191, 31),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectKernelLogs",
                           position: (192, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (192, 33),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectKernelModules",
                           position: (193, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (193, 36),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectKernelTunables",
                           position: (194, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (194, 37),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectProc",
                           position: (195, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "invisible",
                           position: (195, 28),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "ProtectSystem",
                           position: (196, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "full",
                           position: (196, 30),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "RemoveIPC",
                           position: (197, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (197, 25),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "RestrictAddressFamilies",
                           position: (198, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "AF_INET AF_INET6",
                           position: (198, 40),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "RestrictNamespaces",
                           position: (199, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (199, 34),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "RestrictRealtime",
                           position: (200, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (200, 32),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "RestrictSUIDSGID",
                           position: (201, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (201, 32),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (174, 11),
                     },
                    ],
                    position: (172, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "preStart",
                    position: (205, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mkdir -p config\nrm -f www\nrm -f config/{*.json,*.config}\n\nln -s ",
                    position: (206, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "asf-config",
                     position: (210, 19),
                    },
                   },
                   Raw {
                    content: " config/ASF.json\n\n",
                    position: (210, 30),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "strings",
                       position: (212, 13),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "optionalString",
                         position: (212, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      BinaryOperation {
                       operator: NotEqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (212, 37),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "ipcSettings",
                            position: (212, 41),
                           },
                          ],
                         },
                         default: None,
                        },
                        Map {
                         bindings: [],
                         recursive: false,
                         position: (212, 56),
                        },
                       ],
                       position: (212, 53),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "ln -s ",
                         position: (213, 1),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "ipc-config",
                          position: (213, 21),
                         },
                        },
                        Raw {
                         content: " config/IPC.config\n",
                         position: (213, 32),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n\nln -s ",
                    position: (214, 14),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (216, 19),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "runCommandLocal",
                         position: (216, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "ASF-bots",
                         position: (216, 41),
                        },
                       ],
                      },
                      Map {
                       bindings: [],
                       recursive: false,
                       position: (216, 51),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mkdir -p $out/lib/asf/bots\nfor i in ",
                         position: (217, 1),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "strings",
                            position: (218, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "concatStringsSep",
                              position: (218, 32),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: " ",
                              position: (218, 50),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: PropertyAccess {
                             expression: Variable {
                              identifier: "lists",
                              position: (218, 54),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "map",
                                position: (218, 60),
                               },
                              ],
                             },
                             default: None,
                            },
                            arguments: [
                             Function {
                              argument: Some(
                               "x",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: String {
                               parts: [
                                Expression {
                                 expression: FunctionApplication {
                                  function: Variable {
                                   identifier: "getName",
                                   position: (218, 71),
                                  },
                                  arguments: [
                                   Variable {
                                    identifier: "x",
                                    position: (218, 79),
                                   },
                                  ],
                                 },
                                },
                                Raw {
                                 content: ",",
                                 position: (218, 81),
                                },
                                Expression {
                                 expression: Variable {
                                  identifier: "x",
                                  position: (218, 84),
                                 },
                                },
                               ],
                              },
                              position: (218, 65),
                             },
                             FunctionApplication {
                              function: PropertyAccess {
                               expression: Variable {
                                identifier: "attrsets",
                                position: (218, 90),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "mapAttrsToList",
                                  position: (218, 99),
                                 },
                                ],
                               },
                               default: None,
                              },
                              arguments: [
                               Variable {
                                identifier: "mkBot",
                                position: (218, 114),
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (218, 120),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "bots",
                                   position: (218, 124),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                             },
                            ],
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "; do IFS=\",\";\n  set -- $i\n  ln -s $2 $out/lib/asf/bots/$1\ndone\n",
                         position: (218, 131),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "/lib/asf/bots/* config/\n\n",
                    position: (222, 14),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "strings",
                       position: (224, 13),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "optionalString",
                         position: (224, 21),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (224, 36),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "web-ui",
                          position: (224, 40),
                         },
                         Raw {
                          content: "enable",
                          position: (224, 47),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "ln -s ",
                         position: (225, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (225, 21),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "web-ui",
                             position: (225, 25),
                            },
                            Raw {
                             content: "package",
                             position: (225, 32),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib/dist www\n",
                         position: (225, 40),
                        },
                       ],
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (226, 14),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (167, 13),
              },
             ),
            ],
            recursive: false,
            position: (166, 24),
           },
          ),
         ],
         recursive: false,
         position: (154, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (232, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "buildDocsInSandbox",
            position: (233, 5),
           },
          ],
         },
         Variable {
          identifier: "false",
          position: (233, 26),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "maintainers",
            position: (234, 5),
           },
          ],
         },
         With {
          expression: Variable {
           identifier: "maintainers",
           position: (234, 24),
          },
          target: List {
           elements: [
            Variable {
             identifier: "lom",
             position: (234, 39),
            },
           ],
           position: (234, 37),
          },
          position: (234, 19),
         },
        ),
       ],
       recursive: false,
       position: (232, 10),
      },
     ),
    ],
    recursive: false,
    position: (29, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}