---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "systemdUtils",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: With {
  expression: PropertyAccess {
   expression: Variable {
    identifier: "systemdUtils",
    position: (3, 6),
   },
   attribute_path: AttributePath {
    attributes: [
     Raw {
      content: "lib",
      position: (3, 19),
     },
    ],
   },
   default: None,
  },
  target: With {
   expression: Variable {
    identifier: "lib",
    position: (4, 6),
   },
   target: LetIn {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "checkService",
         position: (7, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "checkUnitConfig",
        position: (7, 18),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "Service",
           position: (7, 35),
          },
         ],
        },
        List {
         elements: [
          FunctionApplication {
           function: Variable {
            identifier: "assertValueOneOf",
            position: (8, 6),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Type",
               position: (8, 24),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "exec",
                 position: (9, 8),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "simple",
                 position: (9, 15),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "forking",
                 position: (9, 24),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "oneshot",
                 position: (9, 34),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "dbus",
                 position: (9, 44),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "notify",
                 position: (9, 51),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "idle",
                 position: (9, 60),
                },
               ],
              },
             ],
             position: (8, 30),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "assertValueOneOf",
            position: (11, 6),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "Restart",
               position: (11, 24),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "no",
                 position: (12, 8),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "on-success",
                 position: (12, 13),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "on-failure",
                 position: (12, 26),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "on-abnormal",
                 position: (12, 39),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "on-abort",
                 position: (12, 53),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "always",
                 position: (12, 64),
                },
               ],
              },
             ],
             position: (11, 33),
            },
           ],
          },
         ],
         position: (7, 44),
        },
       ],
      },
     ),
    ],
    target: Map {
     bindings: [
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "unitOption",
          position: (18, 3),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "mkOptionType",
         position: (18, 16),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (19, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "systemd option",
               position: (19, 13),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "merge",
               position: (20, 5),
              },
             ],
            },
            Function {
             argument: Some(
              "loc",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "defs",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defs'",
                    position: (22, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "filterOverrides",
                   position: (22, 17),
                  },
                  arguments: [
                   Variable {
                    identifier: "defs",
                    position: (22, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defs''",
                    position: (23, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "getValues",
                   position: (23, 18),
                  },
                  arguments: [
                   Variable {
                    identifier: "defs'",
                    position: (23, 28),
                   },
                  ],
                 },
                ),
               ],
               target: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "isList",
                  position: (25, 12),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "head",
                    position: (25, 20),
                   },
                   arguments: [
                    Variable {
                     identifier: "defs''",
                     position: (25, 25),
                    },
                   ],
                  },
                 ],
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "concatLists",
                  position: (26, 14),
                 },
                 arguments: [
                  Variable {
                   identifier: "defs''",
                   position: (26, 26),
                  },
                 ],
                },
                else_: FunctionApplication {
                 function: Variable {
                  identifier: "mergeEqualOption",
                  position: (27, 14),
                 },
                 arguments: [
                  Variable {
                   identifier: "loc",
                   position: (27, 31),
                  },
                  Variable {
                   identifier: "defs'",
                   position: (27, 35),
                  },
                 ],
                },
                position: (25, 9),
               },
               position: (21, 7),
              },
              position: (20, 18),
             },
             position: (20, 13),
            },
           ),
          ],
          recursive: false,
          position: (18, 29),
         },
        ],
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "sharedOptions",
          position: (30, 3),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (32, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (32, 14),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (33, 7),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (33, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (34, 7),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (34, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "bool",
                   position: (34, 20),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (35, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "If set to false, this unit will be a symlink to\n/dev/null. This is primarily useful to prevent specific\ntemplate instances\n(e.g. <literal>serial-getty@ttyS0</literal>) from being\nstarted. Note that <literal>enable=true</literal> does not\nmake a unit start by default at boot; if you want that, see\n<literal>wantedBy</literal>.\n",
                  position: (36, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (32, 23),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "requiredBy",
             position: (46, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (46, 18),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (47, 7),
                 },
                ],
               },
               List {
                elements: [],
                position: (47, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (48, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (48, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (48, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (48, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (49, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Units that require (i.e. depend on and need to go down with)\nthis unit. The discussion under <literal>wantedBy</literal>\napplies here as well: inverse <literal>.requires</literal>\nsymlinks are established.\n",
                  position: (50, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (46, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "wantedBy",
             position: (57, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (57, 16),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (58, 7),
                 },
                ],
               },
               List {
                elements: [],
                position: (58, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (59, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (59, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (59, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (59, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (60, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Units that want (i.e. depend on) this unit. The standard way\nto make a unit start by default at boot is to set this option\nto <literal>[ \"multi-user.target\" ]</literal>. That's despite\nthe fact that the systemd.unit(5) manpage says this option\ngoes in the <literal>[Install]</literal> section that controls\nthe behaviour of <literal>systemctl enable</literal>. Since\nsuch a process is stateful and thus contrary to the design of\nNixOS, setting this option instead causes the equivalent\ninverse <literal>.wants</literal> symlink to be present,\nestablishing the same desired relationship in a stateless way.\n",
                  position: (61, 1),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (57, 25),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "aliases",
             position: (74, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (74, 15),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (75, 7),
                 },
                ],
               },
               List {
                elements: [],
                position: (75, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (76, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (76, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (76, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "unitNameType",
                  position: (76, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (77, 7),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Aliases of that unit.",
                  position: (77, 22),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (74, 24),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (30, 19),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "concreteUnitOptions",
          position: (82, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "sharedOptions",
          position: (82, 25),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "text",
               position: (84, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (84, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (85, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (85, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (85, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (85, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (85, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (86, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (86, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (87, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Text of this systemd unit.",
                    position: (87, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (84, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unit",
               position: (90, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (90, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (91, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (91, 18),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (92, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The generated unit.",
                    position: (92, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (90, 21),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (82, 42),
         },
        ],
        position: (82, 39),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "commonUnitOptions",
          position: (97, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "sharedOptions",
          position: (97, 23),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "description",
               position: (99, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (99, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (100, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (101, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (101, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "singleLineStr",
                     position: (101, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (102, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Description of this unit used in systemd messages and progress indicators.",
                    position: (102, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (99, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "documentation",
               position: (105, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (105, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (106, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (106, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (107, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (107, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (107, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (107, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (107, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (108, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A list of URIs referencing documentation for this unit or its configuration.",
                    position: (108, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (105, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "requires",
               position: (111, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (111, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (112, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (112, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (113, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (113, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (113, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (113, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (114, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Start the specified units when this unit is started, and stop\nthis unit when the specified units are stopped or fail.\n",
                    position: (115, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (111, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wants",
               position: (120, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (120, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (121, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (121, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (122, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (122, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (122, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (122, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (123, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Start the specified units when this unit is started.\n",
                    position: (124, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (120, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "after",
               position: (128, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (128, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (129, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (129, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (130, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (130, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (130, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (130, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (131, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If the specified units are started at the same time as\nthis unit, delay this unit until they have started.\n",
                    position: (132, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (128, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "before",
               position: (137, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (137, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (138, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (138, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (139, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (139, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (139, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (139, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (140, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If the specified units are started at the same time as\nthis unit, delay them until this unit has started.\n",
                    position: (141, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (137, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "bindsTo",
               position: (146, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (146, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (147, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (147, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (148, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (148, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (148, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (148, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (149, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Like ‘requires’, but in addition, if the specified units\nunexpectedly disappear, this unit will be stopped as well.\n",
                    position: (150, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (146, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "partOf",
               position: (155, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (155, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (156, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (156, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (157, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (157, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (157, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (157, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (158, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If the specified units are stopped or restarted, then this\nunit is stopped or restarted as well.\n",
                    position: (159, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (155, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "conflicts",
               position: (164, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (164, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (165, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (165, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (166, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (166, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (166, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (166, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (167, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If the specified units are started, then this unit is stopped\nand vice versa.\n",
                    position: (168, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (164, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "requisite",
               position: (173, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (173, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (174, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (174, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (175, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (175, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (175, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (175, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (176, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Similar to requires. However if the units listed are not started,\nthey will not be started and the transaction will fail.\n",
                    position: (177, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (173, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unitConfig",
               position: (182, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (182, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (183, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (183, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (184, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RequiresMountsFor",
                       position: (184, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/data",
                       position: (184, 40),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (184, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (185, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (185, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (185, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (185, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (186, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Unit]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.unit</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (187, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (182, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "restartTriggers",
               position: (194, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (194, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (195, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (195, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (196, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (196, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (196, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (196, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "unspecified",
                       position: (196, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (197, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "An arbitrary list of items such as derivations.  If any item\nin the list changes between reconfigurations, the service will\nbe restarted.\n",
                    position: (198, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (194, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "reloadTriggers",
               position: (204, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (204, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (205, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (205, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (206, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (206, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (206, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (206, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (207, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "An arbitrary list of items such as derivations.  If any item\nin the list changes between reconfigurations, the service will\nbe reloaded.  If anything but a reload trigger changes in the\nunit file, the unit will be restarted instead.\n",
                    position: (208, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (204, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "onFailure",
               position: (215, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (215, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (216, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (216, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (217, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (217, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (217, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitNameType",
                    position: (217, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (218, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A list of one or more units that are activated when\nthis unit enters the \"failed\" state.\n",
                    position: (219, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (215, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "startLimitBurst",
               position: (224, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (224, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (225, 8),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (225, 15),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (225, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (226, 8),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configure unit start rate limiting. Units which are started\nmore than startLimitBurst times within an interval time\ninterval are not permitted to start any more.\n",
                    position: (227, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (224, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "startLimitIntervalSec",
               position: (233, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (233, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (234, 8),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (234, 15),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (234, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (235, 8),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configure unit start rate limiting. Units which are started\nmore than startLimitBurst times within an interval time\ninterval are not permitted to start any more.\n",
                    position: (236, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (233, 38),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (97, 40),
         },
        ],
        position: (97, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "serviceOptions",
          position: (245, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (245, 20),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "environment",
               position: (247, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (247, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (248, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (248, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (249, 7),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (249, 19),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (249, 26),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "nullOr",
                      position: (249, 35),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "oneOf",
                        position: (249, 43),
                       },
                       arguments: [
                        List {
                         elements: [
                          Variable {
                           identifier: "str",
                           position: (249, 51),
                          },
                          Variable {
                           identifier: "path",
                           position: (249, 55),
                          },
                          Variable {
                           identifier: "package",
                           position: (249, 60),
                          },
                         ],
                         position: (249, 49),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (249, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (250, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PATH",
                       position: (250, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/foo/bar/bin",
                       position: (250, 27),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "LANG",
                       position: (250, 42),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "nl_NL.UTF-8",
                       position: (250, 50),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (250, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (251, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Environment variables passed to the service's processes.",
                    position: (251, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (247, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "path",
               position: (254, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (254, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (255, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (255, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (256, 7),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (256, 19),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (256, 26),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "oneOf",
                      position: (256, 34),
                     },
                     arguments: [
                      List {
                       elements: [
                        Variable {
                         identifier: "package",
                         position: (256, 42),
                        },
                        Variable {
                         identifier: "str",
                         position: (256, 50),
                        },
                       ],
                       position: (256, 40),
                      },
                     ],
                    },
                   ],
                  },
                  position: (256, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (257, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Packages added to the service's <envar>PATH</envar>\nenvironment variable.  Both the <filename>bin</filename>\nand <filename>sbin</filename> subdirectories of each\npackage are added.\n",
                    position: (258, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (254, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "serviceConfig",
               position: (265, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (265, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (266, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (266, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (267, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RestartSec",
                       position: (268, 11),
                      },
                     ],
                    },
                    Int {
                     value: 5,
                     position: (268, 24),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (268, 9),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (270, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (270, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "addCheck",
                      position: (270, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (270, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrsOf",
                        position: (270, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "unitOption",
                      position: (270, 44),
                     },
                    ],
                   },
                   Variable {
                    identifier: "checkService",
                    position: (270, 56),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (271, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Service]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.service</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (272, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (265, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "script",
               position: (279, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (279, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (280, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (280, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (280, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (281, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (282, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed as the service's main process.",
                    position: (282, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (279, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "scriptArgs",
               position: (285, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (285, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (286, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (286, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (286, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (287, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (288, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Arguments passed to the main process script.",
                    position: (288, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (285, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "preStart",
               position: (291, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (291, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (292, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (292, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (292, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (293, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (294, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed before the service's main process\nis started.\n",
                    position: (295, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (291, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "postStart",
               position: (300, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (300, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (301, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (301, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (301, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (302, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (303, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed after the service's main process\nis started.\n",
                    position: (304, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (300, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "reload",
               position: (309, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (309, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (310, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (310, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (310, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (311, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (312, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed when the service's main process\nis reloaded.\n",
                    position: (313, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (309, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "preStop",
               position: (318, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (318, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (319, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (319, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (319, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (320, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (321, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed to stop the service.\n",
                    position: (322, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (318, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "postStop",
               position: (326, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (326, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (327, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (327, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (327, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (328, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (329, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Shell commands executed after the service's main process\nhas exited.\n",
                    position: (330, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (326, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "restartIfChanged",
               position: (335, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (335, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (336, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (336, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (336, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (337, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (337, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (338, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether the service should be restarted during a NixOS\nconfiguration switch if its definition has changed.\n",
                    position: (339, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (335, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "reloadIfChanged",
               position: (344, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (344, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (345, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (345, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (345, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (346, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (346, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (347, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether the service should be reloaded during a NixOS\nconfiguration switch if its definition has changed.  If\nenabled, the value of <option>restartIfChanged</option> is\nignored.\n\nThis option should not be used anymore in favor of\n<option>reloadTriggers</option> which allows more granular\ncontrol of when a service is reloaded and when a service\nis restarted.\n",
                    position: (348, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (344, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "stopIfChanged",
               position: (360, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (360, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (361, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (361, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (361, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (362, 7),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (362, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (363, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If set, a changed unit is restarted by calling\n<command>systemctl stop</command> in the old configuration,\nthen <command>systemctl start</command> in the new one.\nOtherwise, it is restarted in a single step using\n<command>systemctl restart</command> in the new configuration.\nThe latter is less correct because it runs the\n<literal>ExecStop</literal> commands from the new\nconfiguration.\n",
                    position: (364, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (360, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "startAt",
               position: (375, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (375, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (376, 7),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (376, 19),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "either",
                    position: (376, 26),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (376, 33),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "listOf",
                      position: (376, 38),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (376, 45),
                      },
                     ],
                    },
                   ],
                  },
                  position: (376, 14),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (377, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (377, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (378, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Sun 14:00:00",
                    position: (378, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (379, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Automatically start this unit at the given date/time, which\nmust be in the format described in\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry>.  This is equivalent\nto adding a corresponding timer unit with\n<option>OnCalendar</option> set to the value given here.\n",
                    position: (380, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (387, 7),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "v",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "isList",
                     position: (387, 21),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (387, 28),
                     },
                    ],
                   },
                   then: Variable {
                    identifier: "v",
                    position: (387, 35),
                   },
                   else_: List {
                    elements: [
                     Variable {
                      identifier: "v",
                      position: (387, 44),
                     },
                    ],
                    position: (387, 42),
                   },
                   position: (387, 18),
                  },
                  position: (387, 15),
                 },
                ),
               ],
               recursive: false,
               position: (375, 24),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (245, 41),
         },
        ],
        position: (245, 38),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "socketOptions",
          position: (393, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (393, 19),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenStreams",
               position: (395, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (395, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (396, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (396, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (397, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (397, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (397, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (397, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (397, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (398, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "0.0.0.0:993",
                      position: (398, 20),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/run/my-socket",
                      position: (398, 34),
                     },
                    ],
                   },
                  ],
                  position: (398, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (399, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "For each item in this list, a <literal>ListenStream</literal>\noption in the <literal>[Socket]</literal> section will be created.\n",
                    position: (400, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (395, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenDatagrams",
               position: (405, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (405, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (406, 7),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (406, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (407, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (407, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (407, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (407, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (407, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (408, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "0.0.0.0:993",
                      position: (408, 20),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/run/my-socket",
                      position: (408, 34),
                     },
                    ],
                   },
                  ],
                  position: (408, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (409, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "For each item in this list, a <literal>ListenDatagram</literal>\noption in the <literal>[Socket]</literal> section will be created.\n",
                    position: (410, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (405, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "socketConfig",
               position: (415, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (415, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (416, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (416, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (417, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ListenStream",
                       position: (417, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/my-socket",
                       position: (417, 35),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (417, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (418, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (418, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (418, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (418, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (419, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Socket]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.socket</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (420, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (415, 29),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (393, 40),
         },
        ],
        position: (393, 37),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "timerOptions",
          position: (430, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (430, 18),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "timerConfig",
               position: (432, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (432, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (433, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (433, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (434, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "OnCalendar",
                       position: (434, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Sun 14:00:00",
                       position: (434, 33),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Unit",
                       position: (434, 48),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "foo.service",
                       position: (434, 56),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (434, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (435, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (435, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (435, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (435, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (436, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Timer]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.timer</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> and\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry> for details.\n",
                    position: (437, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (432, 28),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (430, 39),
         },
        ],
        position: (430, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "pathOptions",
          position: (449, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (449, 17),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pathConfig",
               position: (451, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (451, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (452, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (452, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (453, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PathChanged",
                       position: (453, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/some/path",
                       position: (453, 34),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Unit",
                       position: (453, 47),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "changedpath.service",
                       position: (453, 55),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (453, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (454, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (454, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (454, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (454, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (455, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Path]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.path</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (456, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (451, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (449, 38),
         },
        ],
        position: (449, 35),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "mountOptions",
          position: (466, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (466, 18),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "what",
               position: (468, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (468, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (469, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/dev/sda1",
                    position: (469, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (470, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (470, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (470, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (471, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Absolute path of device node, file or other resource. (Mandatory)",
                    position: (471, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (468, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "where",
               position: (474, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (474, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (475, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/mnt",
                    position: (475, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (476, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (476, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (476, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (477, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Absolute path of a directory of the mount point.\nWill be created if it doesn't exist. (Mandatory)\n",
                    position: (478, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (474, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (483, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (483, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (484, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (485, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ext4",
                    position: (485, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (486, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (486, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (486, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (487, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "File system type.",
                    position: (487, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (483, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "options",
               position: (490, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (490, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (491, 7),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (492, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "noatime",
                    position: (492, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (493, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (493, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "commas",
                     position: (493, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (494, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Options used to mount the file system.",
                    position: (494, 22),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (490, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mountConfig",
               position: (497, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (497, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (498, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (498, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (499, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "DirectoryMode",
                       position: (499, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "0775",
                       position: (499, 36),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (499, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (500, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (500, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (500, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (500, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (501, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Mount]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.mount</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (502, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (497, 28),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (466, 39),
         },
        ],
        position: (466, 36),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "automountOptions",
          position: (510, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (510, 22),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "where",
               position: (512, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (512, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (513, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/mnt",
                    position: (513, 18),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (514, 7),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (514, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (514, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (515, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Absolute path of a directory of the mount point.\nWill be created if it doesn't exist. (Mandatory)\n",
                    position: (516, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (512, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "automountConfig",
               position: (521, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (521, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (522, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (522, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (523, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "DirectoryMode",
                       position: (523, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "0775",
                       position: (523, 36),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (523, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (524, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (524, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (524, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (524, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (525, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Automount]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.automount</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (526, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (521, 32),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (510, 43),
         },
        ],
        position: (510, 40),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "targetOptions",
          position: (534, 3),
         },
        ],
       },
       Variable {
        identifier: "commonUnitOptions",
        position: (534, 19),
       },
      ),
      KeyValue(
       AttributePath {
        attributes: [
         Raw {
          content: "sliceOptions",
          position: (536, 3),
         },
        ],
       },
       BinaryOperation {
        operator: Update,
        operands: [
         Variable {
          identifier: "commonUnitOptions",
          position: (536, 18),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sliceConfig",
               position: (538, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (538, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (539, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (539, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (540, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "MemoryMax",
                       position: (540, 19),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "2G",
                       position: (540, 32),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (540, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (541, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (541, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (541, 20),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "unitOption",
                    position: (541, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (542, 7),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Each attribute in this set specifies an option in the\n<literal>[Slice]</literal> section of the unit.  See\n<citerefentry><refentrytitle>systemd.slice</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry> for details.\n",
                    position: (543, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (538, 28),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (536, 39),
         },
        ],
        position: (536, 36),
       },
      ),
     ],
     recursive: true,
     position: (16, 4),
    },
    position: (6, 1),
   },
   position: (4, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}