---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isLocalPath",
        position: (7, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (8, 5),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "substring",
                 position: (8, 14),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Int {
               value: 0,
               position: (8, 24),
              },
              Int {
               value: 1,
               position: (8, 26),
              },
              Variable {
               identifier: "x",
               position: (8, 28),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "/",
               position: (8, 34),
              },
             ],
            },
           ],
           position: (8, 30),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (9, 8),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "substring",
                 position: (9, 17),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Int {
               value: 0,
               position: (9, 27),
              },
              Int {
               value: 1,
               position: (9, 29),
              },
              Variable {
               identifier: "x",
               position: (9, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: ".",
               position: (9, 37),
              },
             ],
            },
           ],
           position: (9, 33),
          },
         ],
         position: (9, 5),
        },
        BinaryOperation {
         operator: EqualTo,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (10, 8),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "match",
               position: (10, 17),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "[.*:.*]",
               position: (10, 24),
              },
             ],
            },
           ],
          },
          Variable {
           identifier: "null",
           position: (10, 36),
          },
         ],
         position: (10, 33),
        },
       ],
       position: (10, 5),
      },
      position: (7, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkExcludeFile",
        position: (12, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (14, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeText",
           position: (14, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "excludefile",
           position: (14, 21),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (14, 35),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "\n",
             position: (14, 53),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (14, 57),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "exclude",
              position: (14, 61),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ],
      },
      position: (12, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkKeepArgs",
        position: (16, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatStringsSep",
        position: (19, 5),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: " ",
           position: (19, 23),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (20, 8),
         },
         arguments: [
          Function {
           argument: Some(
            "x",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "y",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: String {
             parts: [
              Raw {
               content: "--keep-",
               position: (20, 31),
              },
              Expression {
               expression: Variable {
                identifier: "x",
                position: (20, 40),
               },
              },
              Raw {
               content: "=",
               position: (20, 42),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (20, 45),
                },
                arguments: [
                 Variable {
                  identifier: "y",
                  position: (20, 54),
                 },
                ],
               },
              },
             ],
            },
            position: (20, 27),
           },
           position: (20, 24),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (20, 59),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "prune",
              position: (20, 63),
             },
             Raw {
              content: "keep",
              position: (20, 69),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ],
      },
      position: (16, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBackupScript",
        position: (22, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Addition,
       operands: [
        BinaryOperation {
         operator: Addition,
         operands: [
          BinaryOperation {
           operator: Addition,
           operands: [
            BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                String {
                 parts: [
                  Raw {
                   content: "on_exit()\n{\n  exitStatus=$?\n  # Reset the EXIT handler, or else we're called again on 'exit' below\n  trap - EXIT\n  ",
                   position: (23, 1),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (28, 9),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "postHook",
                       position: (28, 13),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n  exit $exitStatus\n}\ntrap 'on_exit' INT TERM QUIT EXIT\n\narchiveName=\"",
                   position: (28, 22),
                  },
                  Expression {
                   expression: IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (33, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "archiveBaseName",
                          position: (33, 27),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "null",
                       position: (33, 46),
                      },
                     ],
                     position: (33, 43),
                    },
                    then: String {
                     parts: [],
                    },
                    else_: BinaryOperation {
                     operator: Addition,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (33, 64),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "archiveBaseName",
                          position: (33, 68),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "-",
                         position: (33, 87),
                        },
                       ],
                      },
                     ],
                     position: (33, 84),
                    },
                    position: (33, 20),
                   },
                  },
                  Raw {
                   content: "$(date ",
                   position: (33, 90),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (33, 99),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "dateFormat",
                       position: (33, 103),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ")\"\narchiveSuffix=\"",
                   position: (33, 114),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "optionalString",
                     position: (34, 22),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (34, 37),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "appendFailedSuffix",
                         position: (34, 41),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: ".failed",
                        position: (34, 61),
                       },
                      ],
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\"\n",
                   position: (34, 70),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (35, 7),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "preHook",
                       position: (35, 11),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n",
                   position: (35, 19),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (36, 8),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (36, 23),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "doInit",
                      position: (36, 27),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "# Run borg init if the repo doesn't exist yet\nif ! borg list $extraArgs > /dev/null; then\n  borg init $extraArgs \\\n    --encryption ",
                     position: (37, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (40, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "encryption",
                         position: (40, 28),
                        },
                        Raw {
                         content: "mode",
                         position: (40, 39),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: " \\\n    $extraInitArgs\n  ",
                     position: (40, 44),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (42, 9),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "postInit",
                         position: (42, 13),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\nfi\n",
                     position: (42, 22),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (36, 6),
              },
              String {
               parts: [
                Raw {
                 content: "(\n  set -o pipefail\n  ",
                 position: (45, 1),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (47, 9),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (47, 25),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dumpCommand",
                         position: (47, 29),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (47, 44),
                     },
                    ],
                    position: (47, 41),
                   },
                   String {
                    parts: [
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (47, 54),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (47, 69),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "dumpCommand",
                            position: (47, 73),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: " | \\",
                      position: (47, 85),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n  borg create $extraArgs \\\n    --compression ",
                 position: (47, 92),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (49, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "compression",
                     position: (49, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " \\\n    --exclude-from ",
                 position: (49, 41),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "mkExcludeFile",
                   position: (50, 26),
                  },
                  arguments: [
                   Variable {
                    identifier: "cfg",
                    position: (50, 40),
                   },
                  ],
                 },
                },
                Raw {
                 content: " \\\n    $extraCreateArgs \\\n    \"::$archiveName$archiveSuffix\" \\\n    ",
                 position: (50, 44),
                },
                Expression {
                 expression: IfThenElse {
                  predicate: BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (53, 14),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "paths",
                        position: (53, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (53, 27),
                    },
                   ],
                   position: (53, 24),
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "-",
                     position: (53, 38),
                    },
                   ],
                  },
                  else_: FunctionApplication {
                   function: Variable {
                    identifier: "escapeShellArgs",
                    position: (53, 46),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (53, 62),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "paths",
                        position: (53, 66),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  position: (53, 11),
                 },
                },
                Raw {
                 content: "\n)\n",
                 position: (53, 72),
                },
               ],
              },
             ],
             position: (44, 6),
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalString",
              position: (55, 8),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (55, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "appendFailedSuffix",
                  position: (55, 27),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [
                Raw {
                 content: "borg rename $extraArgs \\\n  \"::$archiveName$archiveSuffix\" \"$archiveName\"\n",
                 position: (56, 1),
                },
               ],
              },
             ],
            },
           ],
           position: (55, 6),
          },
          String {
           parts: [
            Raw {
             content: "",
             position: (59, 1),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (59, 7),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postCreate",
                 position: (59, 11),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "\n",
             position: (59, 22),
            },
           ],
          },
         ],
         position: (58, 6),
        },
        FunctionApplication {
         function: Variable {
          identifier: "optionalString",
          position: (60, 8),
         },
         arguments: [
          BinaryOperation {
           operator: NotEqualTo,
           operands: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (60, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "prune",
                position: (60, 28),
               },
               Raw {
                content: "keep",
                position: (60, 34),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [],
             recursive: false,
             position: (60, 42),
            },
           ],
           position: (60, 39),
          },
          String {
           parts: [
            Raw {
             content: "borg prune $extraArgs \\\n  ",
             position: (61, 1),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "mkKeepArgs",
               position: (62, 9),
              },
              arguments: [
               Variable {
                identifier: "cfg",
                position: (62, 20),
               },
              ],
             },
            },
            Raw {
             content: " \\\n  ",
             position: (62, 24),
            },
            Expression {
             expression: FunctionApplication {
              function: Variable {
               identifier: "optionalString",
               position: (63, 9),
              },
              arguments: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (63, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "prune",
                     position: (63, 29),
                    },
                    Raw {
                     content: "prefix",
                     position: (63, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 Variable {
                  identifier: "null",
                  position: (63, 45),
                 },
                ],
                position: (63, 42),
               },
               String {
                parts: [
                 Raw {
                  content: "--prefix ",
                  position: (63, 52),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "escapeShellArg",
                    position: (63, 63),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (63, 78),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "prune",
                        position: (63, 82),
                       },
                       Raw {
                        content: "prefix",
                        position: (63, 88),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Raw {
                  content: " \\",
                  position: (63, 95),
                 },
                ],
               },
              ],
             },
            },
            Raw {
             content: "\n  $extraPruneArgs\n",
             position: (63, 100),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (65, 7),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "postPrune",
                 position: (65, 11),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "\n",
             position: (65, 21),
            },
           ],
          },
         ],
        },
       ],
       position: (60, 6),
      },
      position: (22, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkPassEnv",
        position: (68, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: With {
       expression: PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (68, 25),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "encryption",
           position: (68, 29),
          },
         ],
        },
        default: None,
       },
       target: IfThenElse {
        predicate: BinaryOperation {
         operator: NotEqualTo,
         operands: [
          Variable {
           identifier: "passCommand",
           position: (69, 8),
          },
          Variable {
           identifier: "null",
           position: (69, 23),
          },
         ],
         position: (69, 20),
        },
        then: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "BORG_PASSCOMMAND",
              position: (70, 9),
             },
            ],
           },
           Variable {
            identifier: "passCommand",
            position: (70, 28),
           },
          ),
         ],
         recursive: false,
         position: (70, 7),
        },
        else_: IfThenElse {
         predicate: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           Variable {
            identifier: "passphrase",
            position: (71, 13),
           },
           Variable {
            identifier: "null",
            position: (71, 27),
           },
          ],
          position: (71, 24),
         },
         then: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "BORG_PASSPHRASE",
               position: (72, 9),
              },
             ],
            },
            Variable {
             identifier: "passphrase",
             position: (72, 27),
            },
           ),
          ],
          recursive: false,
          position: (72, 7),
         },
         else_: Map {
          bindings: [],
          recursive: false,
          position: (73, 10),
         },
         position: (71, 10),
        },
        position: (69, 5),
       },
       position: (68, 20),
      },
      position: (68, 15),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBackupService",
        position: (75, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "userHome",
             position: (77, 7),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "config",
            position: (77, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (77, 25),
             },
             Raw {
              content: "users",
              position: (77, 31),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (77, 39),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "user",
                  position: (77, 43),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "home",
              position: (77, 49),
             },
            ],
           },
           default: None,
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "nameValuePair",
          position: (78, 8),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "borgbackup-job-",
             position: (78, 23),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (78, 40),
             },
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (79, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "BorgBackup job ",
                position: (79, 22),
               },
               Expression {
                expression: Variable {
                 identifier: "name",
                 position: (79, 39),
                },
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "path",
                position: (80, 7),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "pkgs",
               position: (80, 19),
              },
              target: List {
               elements: [
                Variable {
                 identifier: "borgbackup",
                 position: (81, 9),
                },
                Variable {
                 identifier: "openssh",
                 position: (81, 20),
                },
               ],
               position: (80, 25),
              },
              position: (80, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "script",
                position: (83, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkBackupScript",
               position: (83, 16),
              },
              arguments: [
               Variable {
                identifier: "cfg",
                position: (83, 31),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "serviceConfig",
                position: (84, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "User",
                   position: (85, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (85, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (85, 20),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "Group",
                   position: (86, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (86, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (86, 21),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "CPUSchedulingPolicy",
                   position: (88, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "idle",
                   position: (88, 32),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "IOSchedulingClass",
                   position: (89, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "idle",
                   position: (89, 30),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ProtectSystem",
                   position: (90, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "strict",
                   position: (90, 26),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ReadWritePaths",
                   position: (91, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  List {
                   elements: [
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "userHome",
                        position: (92, 16),
                       },
                      },
                      Raw {
                       content: "/.config/borg",
                       position: (92, 25),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "userHome",
                        position: (92, 43),
                       },
                      },
                      Raw {
                       content: "/.cache/borg",
                       position: (92, 52),
                      },
                     ],
                    },
                   ],
                   position: (92, 11),
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (93, 14),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "readWritePaths",
                        position: (93, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (95, 14),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "isLocalPath",
                        position: (95, 24),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (95, 36),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "repo",
                            position: (95, 40),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (95, 46),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "repo",
                          position: (95, 50),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ],
                   position: (95, 11),
                  },
                 ],
                 position: (93, 11),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "PrivateTmp",
                   position: (96, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (96, 22),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "privateTmp",
                    position: (96, 26),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (84, 23),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "environment",
                position: (98, 7),
               },
              ],
             },
             BinaryOperation {
              operator: Update,
              operands: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "BORG_REPO",
                     position: (99, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (99, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "repo",
                      position: (99, 25),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 Inherit(
                  Some(
                   Variable {
                    identifier: "cfg",
                    position: (100, 18),
                   },
                  ),
                  [
                   Raw {
                    content: "extraArgs",
                    position: (100, 23),
                   },
                   Raw {
                    content: "extraInitArgs",
                    position: (100, 33),
                   },
                   Raw {
                    content: "extraCreateArgs",
                    position: (100, 47),
                   },
                   Raw {
                    content: "extraPruneArgs",
                    position: (100, 63),
                   },
                  ],
                 ),
                ],
                recursive: false,
                position: (98, 21),
               },
               BinaryOperation {
                operator: Update,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkPassEnv",
                   position: (101, 13),
                  },
                  arguments: [
                   Variable {
                    identifier: "cfg",
                    position: (101, 23),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (101, 31),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (101, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (101, 28),
               },
              ],
              position: (101, 9),
             },
            ),
           ],
           recursive: false,
           position: (78, 47),
          },
         ],
        },
        position: (76, 5),
       },
       position: (75, 27),
      },
      position: (75, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBackupTimers",
        position: (104, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "nameValuePair",
         position: (105, 5),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "borgbackup-job-",
            position: (105, 20),
           },
           Expression {
            expression: Variable {
             identifier: "name",
             position: (105, 37),
            },
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "description",
               position: (106, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "BorgBackup job ",
               position: (106, 22),
              },
              Expression {
               expression: Variable {
                identifier: "name",
                position: (106, 39),
               },
              },
              Raw {
               content: " timer",
               position: (106, 44),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wantedBy",
               position: (107, 7),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "timers.target",
                 position: (107, 21),
                },
               ],
              },
             ],
             position: (107, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "timerConfig",
               position: (108, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "Persistent",
                  position: (109, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (109, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "persistentTimer",
                   position: (109, 26),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "OnCalendar",
                  position: (110, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (110, 22),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "startAt",
                   position: (110, 26),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (108, 21),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "after",
               position: (113, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "optional",
              position: (113, 15),
             },
             arguments: [
              BinaryOperation {
               operator: LogicalAnd,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (113, 25),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "persistentTimer",
                    position: (113, 29),
                   },
                  ],
                 },
                 default: None,
                },
                UnaryOperation {
                 operator: Not,
                 operand: FunctionApplication {
                  function: Variable {
                   identifier: "isLocalPath",
                   position: (113, 49),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (113, 61),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "repo",
                       position: (113, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 position: (113, 48),
                },
               ],
               position: (113, 45),
              },
              String {
               parts: [
                Raw {
                 content: "network-online.target",
                 position: (113, 72),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (105, 44),
         },
        ],
       },
       position: (104, 26),
      },
      position: (104, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkWrapperDrv",
        position: (117, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "set",
         default: Some(
          Map {
           bindings: [],
           recursive: false,
           position: (118, 29),
          },
         ),
        },
        FunctionArgument {
         identifier: "name",
         default: None,
        },
        FunctionArgument {
         identifier: "original",
         default: None,
        },
       ],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (120, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "runCommand",
           position: (120, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Expression {
           expression: Variable {
            identifier: "name",
            position: (120, 24),
           },
          },
          Raw {
           content: "-wrapper",
           position: (120, 29),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "buildInputs",
              position: (121, 7),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (121, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "makeWrapper",
                 position: (121, 28),
                },
               ],
              },
              default: None,
             },
            ],
            position: (121, 21),
           },
          ),
         ],
         recursive: false,
         position: (120, 39),
        },
        With {
         expression: Variable {
          identifier: "lib",
          position: (122, 13),
         },
         target: String {
          parts: [
           Raw {
            content: "makeWrapper \"",
            position: (123, 1),
           },
           Expression {
            expression: Variable {
             identifier: "original",
             position: (123, 22),
            },
           },
           Raw {
            content: "\" \"$out/bin/",
            position: (123, 31),
           },
           Expression {
            expression: Variable {
             identifier: "name",
             position: (123, 45),
            },
           },
           Raw {
            content: "\" \\\n  ",
            position: (123, 50),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "concatStringsSep",
              position: (124, 11),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: " \\\n ",
                 position: (124, 29),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (124, 38),
               },
               arguments: [
                Function {
                 argument: Some(
                  "name",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "value",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: String {
                   parts: [
                    Raw {
                     content: "--set ",
                     position: (124, 69),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "name",
                      position: (124, 77),
                     },
                    },
                    Raw {
                     content: " \"",
                     position: (124, 82),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "value",
                      position: (124, 86),
                     },
                    },
                    Raw {
                     content: "\"",
                     position: (124, 92),
                    },
                   ],
                  },
                  position: (124, 60),
                 },
                 position: (124, 54),
                },
                Variable {
                 identifier: "set",
                 position: (124, 97),
                },
               ],
              },
             ],
            },
           },
           Raw {
            content: "\n",
            position: (124, 102),
           },
          ],
         },
         position: (122, 8),
        },
       ],
      },
      position: (117, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkBorgWrapper",
        position: (127, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkWrapperDrv",
         position: (127, 30),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "original",
               position: (128, 5),
              },
             ],
            },
            String {
             parts: [
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (128, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "borgbackup",
                   position: (128, 24),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "/bin/borg",
               position: (128, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (129, 5),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "borg-job-",
               position: (129, 13),
              },
              Expression {
               expression: Variable {
                identifier: "name",
                position: (129, 24),
               },
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "set",
               position: (130, 5),
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "BORG_REPO",
                    position: (130, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (130, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "repo",
                     position: (130, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (130, 11),
              },
              BinaryOperation {
               operator: Update,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "mkPassEnv",
                  position: (130, 41),
                 },
                 arguments: [
                  Variable {
                   identifier: "cfg",
                   position: (130, 51),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (130, 59),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "environment",
                    position: (130, 63),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (130, 56),
              },
             ],
             position: (130, 37),
            },
           ),
          ],
          recursive: false,
          position: (127, 43),
         },
        ],
       },
       position: (127, 25),
      },
      position: (127, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkActivationScript",
        position: (134, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "install",
             position: (136, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "install -o ",
             position: (136, 18),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (136, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "user",
                 position: (136, 35),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: " -g ",
             position: (136, 40),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (136, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (136, 50),
                },
               ],
              },
              default: None,
             },
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "nameValuePair",
          position: (138, 7),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "borgbackup-job-",
             position: (138, 22),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (138, 39),
             },
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringAfter",
            position: (138, 47),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "users",
                 position: (138, 62),
                },
               ],
              },
             ],
             position: (138, 59),
            },
            BinaryOperation {
             operator: Addition,
             operands: [
              String {
               parts: [
                Raw {
                 content: "# Ensure that the home directory already exists\n# We can't assert createHome == true because that's not the case for root\ncd \"",
                 position: (139, 1),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (141, 15),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "users",
                     position: (141, 22),
                    },
                    Raw {
                     content: "users",
                     position: (141, 28),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (141, 36),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (141, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "home",
                     position: (141, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\"\n",
                 position: (141, 51),
                },
                Expression {
                 expression: Variable {
                  identifier: "install",
                  position: (142, 11),
                 },
                },
                Raw {
                 content: " -d .config/borg\n",
                 position: (142, 19),
                },
                Expression {
                 expression: Variable {
                  identifier: "install",
                  position: (143, 11),
                 },
                },
                Raw {
                 content: " -d .cache/borg\n",
                 position: (143, 19),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (144, 12),
               },
               arguments: [
                BinaryOperation {
                 operator: LogicalAnd,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "isLocalPath",
                    position: (144, 28),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (144, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "repo",
                        position: (144, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  UnaryOperation {
                   operator: Not,
                   operand: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (144, 53),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "removableDevice",
                       position: (144, 57),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (144, 52),
                  },
                 ],
                 position: (144, 49),
                },
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (145, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "install",
                    position: (145, 11),
                   },
                  },
                  Raw {
                   content: " -d ",
                   position: (145, 19),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "escapeShellArg",
                     position: (145, 25),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (145, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "repo",
                         position: (145, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\n",
                   position: (145, 49),
                  },
                 ],
                },
               ],
              },
             ],
             position: (144, 10),
            },
           ],
          },
         ],
        },
        position: (135, 5),
       },
       position: (134, 30),
      },
      position: (134, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkPassAssertion",
        position: (148, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assertion",
             position: (149, 5),
            },
           ],
          },
          With {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (149, 22),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "encryption",
               position: (149, 26),
              },
             ],
            },
            default: None,
           },
           target: BinaryOperation {
            operator: Implication,
            operands: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "mode",
                position: (150, 7),
               },
               String {
                parts: [
                 Raw {
                  content: "none",
                  position: (150, 16),
                 },
                ],
               },
              ],
              position: (150, 12),
             },
             BinaryOperation {
              operator: LogicalOr,
              operands: [
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 Variable {
                  identifier: "passCommand",
                  position: (150, 25),
                 },
                 Variable {
                  identifier: "null",
                  position: (150, 40),
                 },
                ],
                position: (150, 37),
               },
               BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 Variable {
                  identifier: "passphrase",
                  position: (150, 48),
                 },
                 Variable {
                  identifier: "null",
                  position: (150, 62),
                 },
                ],
                position: (150, 59),
               },
              ],
              position: (150, 45),
             },
            ],
            position: (150, 22),
           },
           position: (149, 17),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "message",
             position: (151, 5),
            },
           ],
          },
          BinaryOperation {
           operator: Addition,
           operands: [
            String {
             parts: [
              Raw {
               content: "passCommand or passphrase has to be specified because",
               position: (152, 8),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: " borgbackup.jobs.",
               position: (153, 11),
              },
              Expression {
               expression: Variable {
                identifier: "name",
                position: (153, 30),
               },
              },
              Raw {
               content: ".encryption != \"none\"",
               position: (153, 35),
              },
             ],
            },
           ],
           position: (153, 7),
          },
         ),
        ],
        recursive: false,
        position: (148, 32),
       },
       position: (148, 27),
      },
      position: (148, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRepoService",
        position: (156, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "nameValuePair",
         position: (157, 5),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "borgbackup-repo-",
            position: (157, 20),
           },
           Expression {
            expression: Variable {
             identifier: "name",
             position: (157, 38),
            },
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "description",
               position: (158, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "Create BorgBackup repository ",
               position: (158, 22),
              },
              Expression {
               expression: Variable {
                identifier: "name",
                position: (158, 53),
               },
              },
              Raw {
               content: " directory",
               position: (158, 58),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "script",
               position: (159, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "mkdir -p ",
               position: (160, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "escapeShellArg",
                 position: (160, 20),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (160, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (160, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\nchown ",
               position: (160, 44),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (161, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "user",
                   position: (161, 21),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: ":",
               position: (161, 26),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (161, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "group",
                   position: (161, 33),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: " ",
               position: (161, 39),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "escapeShellArg",
                 position: (161, 42),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (161, 57),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (161, 61),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (161, 66),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "serviceConfig",
               position: (163, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "Type",
                  position: (165, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "oneshot",
                  position: (165, 17),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (163, 23),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wantedBy",
               position: (167, 7),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "multi-user.target",
                 position: (167, 21),
                },
               ],
              },
             ],
             position: (167, 18),
            },
           ),
          ],
          recursive: false,
          position: (157, 45),
         },
        ],
       },
       position: (156, 25),
      },
      position: (156, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAuthorizedKey",
        position: (170, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cfg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "appendOnly",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "key",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "cdCommand",
              position: (173, 7),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "cd ",
              position: (173, 20),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "escapeShellArg",
                position: (173, 25),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (173, 40),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (173, 44),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "restrictedArg",
              position: (174, 7),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "--restrict-to-",
              position: (174, 24),
             },
             Expression {
              expression: IfThenElse {
               predicate: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (174, 43),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "allowSubRepos",
                   position: (174, 47),
                  },
                 ],
                },
                default: None,
               },
               then: String {
                parts: [
                 Raw {
                  content: "path",
                  position: (174, 67),
                 },
                ],
               },
               else_: String {
                parts: [
                 Raw {
                  content: "repository",
                  position: (174, 79),
                 },
                ],
               },
               position: (174, 40),
              },
             },
             Raw {
              content: " .",
              position: (174, 91),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "appendOnlyArg",
              position: (175, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalString",
             position: (175, 23),
            },
            arguments: [
             Variable {
              identifier: "appendOnly",
              position: (175, 38),
             },
             String {
              parts: [
               Raw {
                content: "--append-only",
                position: (175, 50),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "quotaArg",
              position: (176, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalString",
             position: (176, 18),
            },
            arguments: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (176, 34),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "quota",
                   position: (176, 38),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (176, 47),
               },
              ],
              position: (176, 44),
             },
             String {
              parts: [
               Raw {
                content: "--storage-quota ",
                position: (176, 54),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (176, 72),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "quota",
                    position: (176, 76),
                   },
                  ],
                 },
                 default: None,
                },
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "serveCommand",
              position: (177, 7),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "borg serve ",
              position: (177, 23),
             },
             Expression {
              expression: Variable {
               identifier: "restrictedArg",
               position: (177, 36),
              },
             },
             Raw {
              content: " ",
              position: (177, 50),
             },
             Expression {
              expression: Variable {
               identifier: "appendOnlyArg",
               position: (177, 53),
              },
             },
             Raw {
              content: " ",
              position: (177, 67),
             },
             Expression {
              expression: Variable {
               identifier: "quotaArg",
               position: (177, 70),
              },
             },
            ],
           },
          ),
         ],
         target: String {
          parts: [
           Raw {
            content: "command=\"",
            position: (179, 9),
           },
           Expression {
            expression: Variable {
             identifier: "cdCommand",
             position: (179, 20),
            },
           },
           Raw {
            content: " && ",
            position: (179, 30),
           },
           Expression {
            expression: Variable {
             identifier: "serveCommand",
             position: (179, 36),
            },
           },
           Raw {
            content: "\",restrict ",
            position: (179, 49),
           },
           Expression {
            expression: Variable {
             identifier: "key",
             position: (179, 62),
            },
           },
          ],
         },
         position: (171, 5),
        },
        position: (170, 38),
       },
       position: (170, 26),
      },
      position: (170, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkUsersConfig",
        position: (181, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "users",
             position: (182, 5),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (182, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "user",
                 position: (182, 17),
                },
               ],
              },
              default: None,
             },
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "openssh",
                position: (183, 7),
               },
               Raw {
                content: "authorizedKeys",
                position: (183, 15),
               },
               Raw {
                content: "keys",
                position: (183, 30),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (184, 10),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkAuthorizedKey",
                   position: (184, 15),
                  },
                  arguments: [
                   Variable {
                    identifier: "cfg",
                    position: (184, 31),
                   },
                   Variable {
                    identifier: "false",
                    position: (184, 35),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (184, 42),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "authorizedKeys",
                     position: (184, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (185, 12),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkAuthorizedKey",
                   position: (185, 17),
                  },
                  arguments: [
                   Variable {
                    identifier: "cfg",
                    position: (185, 33),
                   },
                   Variable {
                    identifier: "true",
                    position: (185, 37),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (185, 43),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "authorizedKeysAppendOnly",
                     position: (185, 47),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ],
              position: (185, 9),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "useDefaultShell",
                position: (186, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (186, 25),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "group",
                position: (187, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (187, 15),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (187, 19),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "isSystemUser",
                position: (188, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (188, 22),
             },
            ),
           ],
           recursive: false,
           position: (182, 25),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "groups",
             position: (190, 5),
            },
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (190, 14),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (190, 18),
                },
               ],
              },
              default: None,
             },
            },
           ],
          },
          Map {
           bindings: [],
           recursive: false,
           position: (190, 27),
          },
         ),
        ],
        recursive: false,
        position: (181, 30),
       },
       position: (181, 25),
      },
      position: (181, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkKeysAssertion",
        position: (193, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assertion",
             position: (194, 5),
            },
           ],
          },
          BinaryOperation {
           operator: LogicalOr,
           operands: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (194, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "authorizedKeys",
                  position: (194, 21),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (194, 39),
              },
             ],
             position: (194, 36),
            },
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (194, 46),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "authorizedKeysAppendOnly",
                  position: (194, 50),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (194, 78),
              },
             ],
             position: (194, 75),
            },
           ],
           position: (194, 43),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "message",
             position: (195, 5),
            },
           ],
          },
          BinaryOperation {
           operator: Addition,
           operands: [
            String {
             parts: [
              Raw {
               content: "borgbackup.repos.",
               position: (196, 8),
              },
              Expression {
               expression: Variable {
                identifier: "name",
                position: (196, 27),
               },
              },
              Raw {
               content: " does not make sense",
               position: (196, 32),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: " without at least one public key",
               position: (197, 10),
              },
             ],
            },
           ],
           position: (197, 7),
          },
         ),
        ],
        recursive: false,
        position: (193, 32),
       },
       position: (193, 27),
      },
      position: (193, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkSourceAssertions",
        position: (200, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assertion",
             position: (201, 5),
            },
           ],
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "count",
              position: (201, 17),
             },
             arguments: [
              Variable {
               identifier: "isNull",
               position: (201, 23),
              },
              List {
               elements: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (201, 32),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "dumpCommand",
                    position: (201, 36),
                   },
                  ],
                 },
                 default: None,
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (201, 48),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "paths",
                    position: (201, 52),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (201, 30),
              },
             ],
            },
            Int {
             value: 1,
             position: (201, 63),
            },
           ],
           position: (201, 60),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "message",
             position: (202, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "Exactly one of borgbackup.jobs.",
             position: (203, 1),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (203, 40),
             },
            },
            Raw {
             content: ".paths or borgbackup.jobs.",
             position: (203, 45),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (203, 73),
             },
            },
            Raw {
             content: ".dumpCommand\nmust be set.\n",
             position: (203, 78),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (200, 35),
       },
       position: (200, 30),
      },
      position: (200, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkRemovableDeviceAssertions",
        position: (208, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "cfg",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assertion",
             position: (209, 5),
            },
           ],
          },
          BinaryOperation {
           operator: Implication,
           operands: [
            UnaryOperation {
             operator: Not,
             operand: FunctionApplication {
              function: Variable {
               identifier: "isLocalPath",
               position: (209, 19),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (209, 31),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "repo",
                   position: (209, 35),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             position: (209, 17),
            },
            UnaryOperation {
             operator: Not,
             operand: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (209, 45),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "removableDevice",
                 position: (209, 49),
                },
               ],
              },
              default: None,
             },
             position: (209, 44),
            },
           ],
           position: (209, 41),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "message",
             position: (210, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "borgbackup.repos.",
             position: (211, 1),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (211, 26),
             },
            },
            Raw {
             content: ": repo isn't a local path, thus it can't be a removable device!\n",
             position: (211, 31),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (208, 44),
       },
       position: (208, 39),
      },
      position: (208, 33),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (216, 3),
        },
        Raw {
         content: "maintainers",
         position: (216, 8),
        },
       ],
      },
      With {
       expression: Variable {
        identifier: "maintainers",
        position: (216, 27),
       },
       target: List {
        elements: [
         Variable {
          identifier: "dotlambda",
          position: (216, 42),
         },
        ],
        position: (216, 40),
       },
       position: (216, 22),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (217, 3),
        },
        Raw {
         content: "doc",
         position: (217, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./borgbackup.xml",
         position: (217, 14),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (221, 3),
        },
        Raw {
         content: "services",
         position: (221, 11),
        },
        Raw {
         content: "borgbackup",
         position: (221, 20),
        },
        Raw {
         content: "jobs",
         position: (221, 31),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (221, 38),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (222, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "Deduplicating backups using BorgBackup.\nAdding a job will cause a borg-job-NAME wrapper to be added\nto your system path, so that you can perform maintenance easily.\nSee also the chapter about BorgBackup in the NixOS manual.\n",
              position: (223, 1),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (228, 5),
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (228, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "example",
              position: (229, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "literalExpression",
             position: (229, 15),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "  { # for a local backup\n    rootBackup = {\n      paths = \"/\";\n      exclude = [ \"/nix\" ];\n      repo = \"/path/to/local/repo\";\n      encryption = {\n        mode = \"repokey\";\n        passphrase = \"secret\";\n      };\n      compression = \"auto,lzma\";\n      startAt = \"weekly\";\n    };\n  }\n  { # Root backing each day up to a remote backup server. We assume that you have\n    #   * created a password less key: ssh-keygen -N \"\" -t ed25519 -f /path/to/ssh_key\n    #     best practices are: use -t ed25519, /path/to = /run/keys\n    #   * the passphrase is in the file /run/keys/borgbackup_passphrase\n    #   * you have initialized the repository manually\n    paths = [ \"/etc\" \"/home\" ];\n    exclude = [ \"/nix\" \"'**/.cache'\" ];\n    doInit = false;\n    repo =  \"user3@arep.repo.borgbase.com:repo\";\n    encryption = {\n      mode = \"repokey-blake2\";\n      passCommand = \"cat /path/to/passphrase\";\n    };\n    environment = { BORG_RSH = \"ssh -i /path/to/ssh_key\"; };\n    compression = \"auto,lzma\";\n    startAt = \"daily\";\n};\n",
                position: (230, 1),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (261, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (261, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "attrsOf",
                position: (261, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (261, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "submodule",
                  position: (261, 33),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "globalConfig",
                     position: (261, 48),
                    },
                   ],
                  },
                  Variable {
                   identifier: "config",
                   position: (261, 63),
                  },
                 ),
                ],
                target: Function {
                 argument: None,
                 arguments: FunctionArguments {
                  arguments: [
                   FunctionArgument {
                    identifier: "config",
                    default: None,
                   },
                   FunctionArgument {
                    identifier: "name",
                    default: None,
                   },
                  ],
                  ellipsis: true,
                 },
                 definition: Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "options",
                       position: (263, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "paths",
                          position: (265, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (265, 19),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (266, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (266, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "nullOr",
                               position: (266, 32),
                              },
                              arguments: [
                               FunctionApplication {
                                function: Variable {
                                 identifier: "coercedTo",
                                 position: (266, 40),
                                },
                                arguments: [
                                 Variable {
                                  identifier: "str",
                                  position: (266, 50),
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "lib",
                                   position: (266, 54),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "singleton",
                                     position: (266, 58),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "listOf",
                                   position: (266, 69),
                                  },
                                  arguments: [
                                   Variable {
                                    identifier: "str",
                                    position: (266, 76),
                                   },
                                  ],
                                 },
                                ],
                               },
                              ],
                             },
                             position: (266, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (267, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (267, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (268, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Path(s) to back up.\nMutually exclusive with <option>dumpCommand</option>.\n",
                               position: (269, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (272, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "/home/user",
                               position: (272, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (265, 28),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "dumpCommand",
                          position: (275, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (275, 25),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (276, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (276, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "nullOr",
                               position: (276, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "path",
                                position: (276, 39),
                               },
                              ],
                             },
                             position: (276, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (277, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (277, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (278, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Backup the stdout of this program instead of filesystem paths.\nMutually exclusive with <option>paths</option>.\n",
                               position: (279, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (282, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "/path/to/createZFSsend.sh",
                               position: (282, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (275, 34),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "repo",
                          position: (285, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (285, 18),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (286, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (286, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (286, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (287, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Remote or local repository to back up to.",
                               position: (287, 28),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (288, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "user@machine:/path/to/repo",
                               position: (288, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (285, 27),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "removableDevice",
                          position: (291, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (291, 29),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (292, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (292, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "bool",
                                position: (292, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (293, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "false",
                             position: (293, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (294, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Whether the repo (which must be local) is a removable device.",
                               position: (294, 28),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (291, 38),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "archiveBaseName",
                          position: (297, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (297, 29),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (298, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (298, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "nullOr",
                                 position: (298, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (298, 34),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "strMatching",
                                   position: (298, 40),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "[^/{}]+",
                                   position: (298, 53),
                                  },
                                 ],
                                },
                               ],
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (299, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "globalConfig",
                                 position: (299, 26),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "networking",
                                   position: (299, 39),
                                  },
                                  Raw {
                                   content: "hostName",
                                   position: (299, 50),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "-",
                               position: (299, 59),
                              },
                              Expression {
                               expression: Variable {
                                identifier: "name",
                                position: (299, 62),
                               },
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "defaultText",
                               position: (300, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "literalExpression",
                              position: (300, 27),
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "\"",
                                 position: (300, 47),
                                },
                                Raw {
                                 content: "$",
                                 position: (300, 48),
                                },
                                Raw {
                                 content: "{config.networking.hostName}-<name>\"",
                                 position: (300, 51),
                                },
                               ],
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (301, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "How to name the created archives. A timestamp, whose format is\ndetermined by <option>dateFormat</option>, will be appended. The full\nname can be modified at runtime (<literal>$archiveName</literal>).\nPlaceholders like <literal>{hostname}</literal> must not be used.\nUse <literal>null</literal> for no base name.\n",
                               position: (302, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (297, 38),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "dateFormat",
                          position: (310, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (310, 24),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (311, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (311, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (311, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (312, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Arguments passed to <command>date</command>\nto create a timestamp suffix for the archive name.\n",
                               position: (313, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (316, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "+%Y-%m-%dT%H:%M:%S",
                               position: (316, 24),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (317, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "-u +%s",
                               position: (317, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (310, 33),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "startAt",
                          position: (320, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (320, 21),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (321, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (321, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "either",
                               position: (321, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "str",
                                position: (321, 39),
                               },
                               FunctionApplication {
                                function: Variable {
                                 identifier: "listOf",
                                 position: (321, 44),
                                },
                                arguments: [
                                 Variable {
                                  identifier: "str",
                                  position: (321, 51),
                                 },
                                ],
                               },
                              ],
                             },
                             position: (321, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (322, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "daily",
                               position: (322, 24),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (323, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "When or how often the backup should run.\nMust be in the format described in\n<citerefentry><refentrytitle>systemd.time</refentrytitle>\n<manvolnum>7</manvolnum></citerefentry>.\nIf you do not want the backup to start\nautomatically, use <literal>[ ]</literal>.\nIt will generate a systemd service borgbackup-job-NAME.\nYou may trigger it manually via systemctl restart borgbackup-job-NAME.\n",
                               position: (324, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (320, 30),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "persistentTimer",
                          position: (335, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (335, 29),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (336, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "false",
                             position: (336, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (337, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (337, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "bool",
                                position: (337, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (338, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "true",
                             position: (338, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (339, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Set the <literal>persistentTimer</literal> option for the\n<citerefentry><refentrytitle>systemd.timer</refentrytitle>\n<manvolnum>5</manvolnum></citerefentry>\nwhich triggers the backup immediately if the last trigger\nwas missed (e.g. if the system was powered down).\n",
                               position: (340, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (335, 38),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "user",
                          position: (348, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (348, 18),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (349, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (349, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (349, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (350, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "The user <command>borg</command> is run as.\nUser or group need read permission\nfor the specified <option>paths</option>.\n",
                               position: (351, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (355, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "root",
                               position: (355, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (348, 27),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "group",
                          position: (358, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (358, 19),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (359, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (359, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (359, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (360, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "The group borg is run as. User or group needs read permission\nfor the specified <option>paths</option>.\n",
                               position: (361, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (364, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "root",
                               position: (364, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (358, 28),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "encryption",
                          position: (367, 11),
                         },
                         Raw {
                          content: "mode",
                          position: (367, 22),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (367, 29),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (368, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (368, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "enum",
                                 position: (368, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "repokey",
                                   position: (369, 16),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "keyfile",
                                   position: (369, 26),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "repokey-blake2",
                                   position: (370, 16),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "keyfile-blake2",
                                   position: (370, 33),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "authenticated",
                                   position: (371, 16),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "authenticated-blake2",
                                   position: (371, 32),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "none",
                                   position: (372, 16),
                                  },
                                 ],
                                },
                               ],
                               position: (368, 31),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (374, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Encryption mode to use. Setting a mode\nother than <literal>\"none\"</literal> requires\nyou to specify a <option>passCommand</option>\nor a <option>passphrase</option>.\n",
                               position: (375, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (380, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "repokey-blake2",
                               position: (380, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (367, 38),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "encryption",
                          position: (383, 11),
                         },
                         Raw {
                          content: "passCommand",
                          position: (383, 22),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (383, 36),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (384, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (384, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "nullOr",
                               position: (384, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "str",
                                position: (384, 39),
                               },
                              ],
                             },
                             position: (384, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (385, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "A command which prints the passphrase to stdout.\nMutually exclusive with <option>passphrase</option>.\n",
                               position: (386, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (389, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (389, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (390, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "cat /path/to/passphrase_file",
                               position: (390, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (383, 45),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "encryption",
                          position: (393, 11),
                         },
                         Raw {
                          content: "passphrase",
                          position: (393, 22),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (393, 35),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (394, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (394, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "nullOr",
                               position: (394, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "str",
                                position: (394, 39),
                               },
                              ],
                             },
                             position: (394, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (395, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "The passphrase the backups are encrypted with.\nMutually exclusive with <option>passCommand</option>.\nIf you do not want the passphrase to be stored in the\nworld-readable Nix store, use <option>passCommand</option>.\n",
                               position: (396, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (401, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "null",
                             position: (401, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (393, 44),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "compression",
                          position: (404, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (404, 25),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (408, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (408, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "strMatching",
                                 position: (408, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "none|(auto,)?(lz4|zstd|zlib|lzma)(,[[:digit:]]{1,2})?",
                                 position: (408, 39),
                                },
                               ],
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (409, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Compression method to use. Refer to\n<command>borg help compression</command>\nfor all available options.\n",
                               position: (410, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (414, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "lz4",
                               position: (414, 24),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (415, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "auto,lzma",
                               position: (415, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (404, 34),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "exclude",
                          position: (418, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (418, 21),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (419, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (419, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "listOf",
                               position: (419, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "str",
                                position: (419, 39),
                               },
                              ],
                             },
                             position: (419, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (420, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Exclude paths matching any of the given patterns. See\n<command>borg help patterns</command> for pattern syntax.\n",
                               position: (421, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (424, 13),
                              },
                             ],
                            },
                            List {
                             elements: [],
                             position: (424, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (425, 13),
                              },
                             ],
                            },
                            List {
                             elements: [
                              String {
                               parts: [
                                Raw {
                                 content: "/home/*/.cache",
                                 position: (426, 16),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "/nix",
                                 position: (427, 16),
                                },
                               ],
                              },
                             ],
                             position: (425, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (418, 30),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "readWritePaths",
                          position: (431, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (431, 28),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (432, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (432, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "listOf",
                               position: (432, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "path",
                                position: (432, 39),
                               },
                              ],
                             },
                             position: (432, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (433, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "By default, borg cannot write anywhere on the system but\n<literal>$HOME/.config/borg</literal> and <literal>$HOME/.cache/borg</literal>.\nIf, for example, your preHook script needs to dump files\nsomewhere, put those directories here.\n",
                               position: (434, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (439, 13),
                              },
                             ],
                            },
                            List {
                             elements: [],
                             position: (439, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (440, 13),
                              },
                             ],
                            },
                            List {
                             elements: [
                              String {
                               parts: [
                                Raw {
                                 content: "/var/backup/mysqldump",
                                 position: (441, 16),
                                },
                               ],
                              },
                             ],
                             position: (440, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (431, 37),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "privateTmp",
                          position: (445, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (445, 24),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (446, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (446, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "bool",
                                position: (446, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (447, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Set the <literal>PrivateTmp</literal> option for\nthe systemd-service. Set to false if you need sockets\nor other files from global /tmp.\n",
                               position: (448, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (452, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "true",
                             position: (452, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (445, 33),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "doInit",
                          position: (455, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (455, 20),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (456, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (456, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "bool",
                                position: (456, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (457, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Run <command>borg init</command> if the\nspecified <option>repo</option> does not exist.\nYou should set this to <literal>false</literal>\nif the repository is located on an external drive\nthat might not always be mounted.\n",
                               position: (458, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (464, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "true",
                             position: (464, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (455, 29),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "appendFailedSuffix",
                          position: (467, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (467, 32),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (468, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (468, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "bool",
                                position: (468, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (469, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Append a <literal>.failed</literal> suffix\nto the archive name, which is only removed if\n<command>borg create</command> has a zero exit status.\n",
                               position: (470, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (474, 13),
                              },
                             ],
                            },
                            Variable {
                             identifier: "true",
                             position: (474, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (467, 41),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "prune",
                          position: (477, 11),
                         },
                         Raw {
                          content: "keep",
                          position: (477, 17),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (477, 24),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (481, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (481, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "attrsOf",
                               position: (481, 32),
                              },
                              arguments: [
                               FunctionApplication {
                                function: Variable {
                                 identifier: "either",
                                 position: (481, 41),
                                },
                                arguments: [
                                 Variable {
                                  identifier: "int",
                                  position: (481, 48),
                                 },
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "strMatching",
                                   position: (481, 53),
                                  },
                                  arguments: [
                                   String {
                                    parts: [
                                     Raw {
                                      content: "[[:digit:]]+[Hdwmy]",
                                      position: (481, 66),
                                     },
                                    ],
                                   },
                                  ],
                                 },
                                ],
                               },
                              ],
                             },
                             position: (481, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (482, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Prune a repository by deleting all archives not matching any of the\nspecified retention options. See <command>borg help prune</command>\nfor the available options.\n",
                               position: (483, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (487, 13),
                              },
                             ],
                            },
                            Map {
                             bindings: [],
                             recursive: false,
                             position: (487, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (488, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "literalExpression",
                              position: (488, 23),
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "{\n  within = \"1d\"; # Keep all archives from the last day\n  daily = 7;\n  weekly = 4;\n  monthly = -1;  # Keep at least one archive for each month\n}\n",
                                 position: (489, 1),
                                },
                               ],
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (477, 33),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "prune",
                          position: (498, 11),
                         },
                         Raw {
                          content: "prefix",
                          position: (498, 17),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (498, 26),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (499, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (499, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "nullOr",
                                 position: (499, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                             arguments: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (499, 34),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "str",
                                  position: (499, 40),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (500, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Only consider archive names starting with this prefix for pruning.\nBy default, only archives created by this job are considered.\nUse <literal>\"\"</literal> or <literal>null</literal> to consider all archives.\n",
                               position: (501, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (505, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "config",
                              position: (505, 23),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "archiveBaseName",
                                position: (505, 30),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "defaultText",
                               position: (506, 13),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "literalExpression",
                              position: (506, 27),
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "archiveBaseName",
                                 position: (506, 46),
                                },
                               ],
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (498, 35),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "environment",
                          position: (509, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (509, 25),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (510, 13),
                              },
                             ],
                            },
                            With {
                             expression: Variable {
                              identifier: "types",
                              position: (510, 25),
                             },
                             target: FunctionApplication {
                              function: Variable {
                               identifier: "attrsOf",
                               position: (510, 32),
                              },
                              arguments: [
                               Variable {
                                identifier: "str",
                                position: (510, 40),
                               },
                              ],
                             },
                             position: (510, 20),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (511, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Environment variables passed to the backup script.\nYou can for example specify which SSH key to use.\n",
                               position: (512, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (515, 13),
                              },
                             ],
                            },
                            Map {
                             bindings: [],
                             recursive: false,
                             position: (515, 23),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (516, 13),
                              },
                             ],
                            },
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "BORG_RSH",
                                  position: (516, 25),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "ssh -i /path/to/key",
                                  position: (516, 37),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (516, 23),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (509, 34),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "preHook",
                          position: (519, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (519, 21),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (520, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (520, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "lines",
                                position: (520, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (521, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Shell commands to run before the backup.\nThis can for example be used to mount file systems.\n",
                               position: (522, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (525, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (526, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "# To add excluded paths at runtime\nextraCreateArgs=\"$extraCreateArgs --exclude /some/path\"\n",
                               position: (527, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (519, 30),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "postInit",
                          position: (532, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (532, 22),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (533, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (533, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "lines",
                                position: (533, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (534, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Shell commands to run after <command>borg init</command>.\n",
                               position: (535, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (537, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (532, 31),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "postCreate",
                          position: (540, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (540, 24),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (541, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (541, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "lines",
                                position: (541, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (542, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Shell commands to run after <command>borg create</command>. The name\nof the created archive is stored in <literal>$archiveName</literal>.\n",
                               position: (543, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (546, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (540, 33),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "postPrune",
                          position: (549, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (549, 23),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (550, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (550, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "lines",
                                position: (550, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (551, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Shell commands to run after <command>borg prune</command>.\n",
                               position: (552, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (554, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (549, 32),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "postHook",
                          position: (557, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (557, 22),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (558, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (558, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "lines",
                                position: (558, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (559, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Shell commands to run just before exit. They are executed\neven if a previous command exits with a non-zero exit code.\nThe latter is available as <literal>$exitStatus</literal>.\n",
                               position: (560, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (564, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (557, 31),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "extraArgs",
                          position: (567, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (567, 23),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (568, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (568, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (568, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (569, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Additional arguments for all <command>borg</command> calls the\nservice has. Handle with care.\n",
                               position: (570, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (573, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (574, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "--remote-path=/path/to/borg",
                               position: (574, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (567, 32),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "extraInitArgs",
                          position: (577, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (577, 27),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (578, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (578, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (578, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (579, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Additional arguments for <command>borg init</command>.\nCan also be set at runtime using <literal>$extraInitArgs</literal>.\n",
                               position: (580, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (583, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (584, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "--append-only",
                               position: (584, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (577, 36),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "extraCreateArgs",
                          position: (587, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (587, 29),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (588, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (588, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (588, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (589, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Additional arguments for <command>borg create</command>.\nCan also be set at runtime using <literal>$extraCreateArgs</literal>.\n",
                               position: (590, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (593, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (594, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "--stats --checkpoint-interval 600",
                               position: (594, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (587, 38),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "extraPruneArgs",
                          position: (597, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkOption",
                         position: (597, 28),
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "type",
                               position: (598, 13),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (598, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "str",
                                position: (598, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "description",
                               position: (599, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "Additional arguments for <command>borg prune</command>.\nCan also be set at runtime using <literal>$extraPruneArgs</literal>.\n",
                               position: (600, 1),
                              },
                             ],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "default",
                               position: (603, 13),
                              },
                             ],
                            },
                            String {
                             parts: [],
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "example",
                               position: (604, 13),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "--save-space",
                               position: (604, 24),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (597, 37),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (263, 19),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (262, 30),
                 },
                 position: (262, 7),
                },
                position: (261, 44),
               },
              ],
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (221, 47),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (612, 3),
        },
        Raw {
         content: "services",
         position: (612, 11),
        },
        Raw {
         content: "borgbackup",
         position: (612, 20),
        },
        Raw {
         content: "repos",
         position: (612, 31),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (612, 39),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (613, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "Serve BorgBackup repositories to given public SSH keys,\nrestricting their access to the repository only.\nSee also the chapter about BorgBackup in the NixOS manual.\nAlso, clients do not need to specify the absolute path when accessing the repository,\ni.e. <literal>user@machine:.</literal> is enough. (Note colon and dot.)\n",
              position: (614, 1),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (620, 5),
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (620, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (621, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (621, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "attrsOf",
                position: (621, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (621, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "submodule",
                  position: (621, 33),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Function {
                argument: None,
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: true,
                },
                definition: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (623, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (624, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (624, 18),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (625, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (625, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "path",
                               position: (625, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (626, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Where to store the backups. Note that the directory\nis created automatically, with correct permissions.\n",
                              position: (627, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (630, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "/var/lib/borgbackup",
                              position: (630, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (624, 27),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "user",
                         position: (633, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (633, 18),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (634, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (634, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (634, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (635, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The user <command>borg serve</command> is run as.\nUser or group needs write permission\nfor the specified <option>path</option>.\n",
                              position: (636, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (640, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "borg",
                              position: (640, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (633, 27),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (643, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (643, 19),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (644, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (644, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (644, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (645, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The group <command>borg serve</command> is run as.\nUser or group needs write permission\nfor the specified <option>path</option>.\n",
                              position: (646, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (650, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "borg",
                              position: (650, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (643, 28),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "authorizedKeys",
                         position: (653, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (653, 28),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (654, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (654, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (654, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (654, 39),
                              },
                             ],
                            },
                            position: (654, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (655, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Public SSH keys that are given full write access to this repository.\nYou should use a different SSH key for each repository you write to, because\nthe specified keys are restricted to running <command>borg serve</command>\nand can only access this single repository.\n",
                              position: (656, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (661, 13),
                             },
                            ],
                           },
                           List {
                            elements: [],
                            position: (661, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (653, 37),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "authorizedKeysAppendOnly",
                         position: (664, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (664, 38),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (665, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (665, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (665, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (665, 39),
                              },
                             ],
                            },
                            position: (665, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (666, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Public SSH keys that can only be used to append new data (archives) to the repository.\nNote that archives can still be marked as deleted and are subsequently removed from disk\nupon accessing the repo with full write access, e.g. when pruning.\n",
                              position: (667, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (671, 13),
                             },
                            ],
                           },
                           List {
                            elements: [],
                            position: (671, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (664, 47),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "allowSubRepos",
                         position: (674, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (674, 27),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (675, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (675, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "bool",
                               position: (675, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (676, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Allow clients to create repositories in subdirectories of the\nspecified <option>path</option>. These can be accessed using\n<literal>user@machine:path/to/subrepo</literal>. Note that a\n<option>quota</option> applies to repositories independently.\nTherefore, if this is enabled, clients can create multiple\nrepositories and upload an arbitrary amount of data.\n",
                              position: (677, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (684, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "false",
                            position: (684, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (674, 36),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "quota",
                         position: (687, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (687, 19),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (689, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (689, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (689, 32),
                             },
                             arguments: [
                              FunctionApplication {
                               function: Variable {
                                identifier: "strMatching",
                                position: (689, 40),
                               },
                               arguments: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "[[:digit:].]+[KMGTP]?",
                                   position: (689, 53),
                                  },
                                 ],
                                },
                               ],
                              },
                             ],
                            },
                            position: (689, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (690, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Storage quota for the repository. This quota is ensured for all\nsub-repositories if <option>allowSubRepos</option> is enabled\nbut not for the overall storage space used.\n",
                              position: (691, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (695, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (695, 23),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "example",
                              position: (696, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "100G",
                              position: (696, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (687, 28),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (623, 19),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (622, 16),
                },
                position: (622, 7),
               },
              ],
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (612, 48),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (706, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (706, 12),
       },
       arguments: [
        With {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "config",
           position: (706, 23),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (706, 30),
            },
            Raw {
             content: "borgbackup",
             position: (706, 39),
            },
           ],
          },
          default: None,
         },
         target: BinaryOperation {
          operator: LogicalOr,
          operands: [
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "jobs",
              position: (706, 51),
             },
             Map {
              bindings: [],
              recursive: false,
              position: (706, 59),
             },
            ],
            position: (706, 56),
           },
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             Variable {
              identifier: "repos",
              position: (706, 66),
             },
             Map {
              bindings: [],
              recursive: false,
              position: (706, 75),
             },
            ],
            position: (706, 72),
           },
          ],
          position: (706, 63),
         },
         position: (706, 18),
        },
        With {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "config",
           position: (707, 11),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (707, 18),
            },
            Raw {
             content: "borgbackup",
             position: (707, 27),
            },
           ],
          },
          default: None,
         },
         target: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "assertions",
               position: (708, 7),
              },
             ],
            },
            BinaryOperation {
             operator: Concatenation,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (709, 9),
               },
               arguments: [
                Variable {
                 identifier: "mkPassAssertion",
                 position: (709, 24),
                },
                Variable {
                 identifier: "jobs",
                 position: (709, 40),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrsToList",
                  position: (710, 12),
                 },
                 arguments: [
                  Variable {
                   identifier: "mkKeysAssertion",
                   position: (710, 27),
                  },
                  Variable {
                   identifier: "repos",
                   position: (710, 43),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "mapAttrsToList",
                    position: (711, 12),
                   },
                   arguments: [
                    Variable {
                     identifier: "mkSourceAssertions",
                     position: (711, 27),
                    },
                    Variable {
                     identifier: "jobs",
                     position: (711, 46),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mapAttrsToList",
                    position: (712, 12),
                   },
                   arguments: [
                    Variable {
                     identifier: "mkRemovableDeviceAssertions",
                     position: (712, 27),
                    },
                    Variable {
                     identifier: "jobs",
                     position: (712, 55),
                    },
                   ],
                  },
                 ],
                 position: (712, 9),
                },
               ],
               position: (711, 9),
              },
             ],
             position: (710, 9),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "system",
               position: (714, 7),
              },
              Raw {
               content: "activationScripts",
               position: (714, 14),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrs'",
              position: (714, 34),
             },
             arguments: [
              Variable {
               identifier: "mkActivationScript",
               position: (714, 44),
              },
              Variable {
               identifier: "jobs",
               position: (714, 63),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (716, 7),
              },
              Raw {
               content: "services",
               position: (716, 15),
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrs'",
                position: (718, 9),
               },
               arguments: [
                Variable {
                 identifier: "mkBackupService",
                 position: (718, 19),
                },
                Variable {
                 identifier: "jobs",
                 position: (718, 35),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrs'",
                position: (720, 12),
               },
               arguments: [
                Variable {
                 identifier: "mkRepoService",
                 position: (720, 22),
                },
                Variable {
                 identifier: "repos",
                 position: (720, 36),
                },
               ],
              },
             ],
             position: (720, 9),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (724, 7),
              },
              Raw {
               content: "timers",
               position: (724, 15),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrs'",
              position: (724, 24),
             },
             arguments: [
              Variable {
               identifier: "mkBackupTimers",
               position: (724, 34),
              },
              FunctionApplication {
               function: Variable {
                identifier: "filterAttrs",
                position: (724, 50),
               },
               arguments: [
                Function {
                 argument: Some(
                  "_",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "cfg",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (724, 71),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "startAt",
                        position: (724, 75),
                       },
                      ],
                     },
                     default: None,
                    },
                    List {
                     elements: [],
                     position: (724, 86),
                    },
                   ],
                   position: (724, 83),
                  },
                  position: (724, 66),
                 },
                 position: (724, 63),
                },
                Variable {
                 identifier: "jobs",
                 position: (724, 90),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (726, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (726, 15),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "mapAttrsToList",
                position: (726, 24),
               },
               arguments: [
                Variable {
                 identifier: "mkUsersConfig",
                 position: (726, 39),
                },
                Variable {
                 identifier: "repos",
                 position: (726, 53),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "environment",
               position: (728, 7),
              },
              Raw {
               content: "systemPackages",
               position: (728, 19),
              },
             ],
            },
            With {
             expression: Variable {
              identifier: "pkgs",
              position: (728, 41),
             },
             target: BinaryOperation {
              operator: Concatenation,
              operands: [
               List {
                elements: [
                 Variable {
                  identifier: "borgbackup",
                  position: (728, 49),
                 },
                ],
                position: (728, 47),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mapAttrsToList",
                 position: (728, 66),
                },
                arguments: [
                 Variable {
                  identifier: "mkBorgWrapper",
                  position: (728, 81),
                 },
                 Variable {
                  identifier: "jobs",
                  position: (728, 95),
                 },
                ],
               },
              ],
              position: (728, 62),
             },
             position: (728, 36),
            },
           ),
          ],
          recursive: false,
          position: (707, 39),
         },
         position: (707, 6),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (215, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}