---
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: (7, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "libDir",
        position: (10, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "/var/lib/bacula",
        position: (10, 13),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fd_cfg",
        position: (12, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (12, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (12, 19),
        },
        Raw {
         content: "bacula-fd",
         position: (12, 28),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fd_conf",
        position: (13, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 13),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (13, 18),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "bacula-fd.conf",
          position: (13, 29),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "Client {\n  Name = \"",
          position: (15, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "fd_cfg",
            position: (16, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (16, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\";\n  FDPort = ",
          position: (16, 31),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (17, 20),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "fd_cfg",
              position: (17, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (17, 36),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ";\n  WorkingDirectory = \"",
          position: (17, 41),
         },
         Expression {
          expression: Variable {
           identifier: "libDir",
           position: (18, 31),
          },
         },
         Raw {
          content: "\";\n  Pid Directory = \"/run\";\n  ",
          position: (18, 38),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "fd_cfg",
            position: (20, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraClientConfig",
              position: (20, 18),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n\n",
          position: (20, 36),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (23, 9),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (23, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (23, 32),
             },
             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: "Director {\n  Name = \"",
                   position: (24, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (25, 19),
                   },
                  },
                  Raw {
                   content: "\";\n  Password = \"",
                   position: (25, 24),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (26, 23),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "password",
                       position: (26, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  Monitor = \"",
                   position: (26, 38),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (27, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "monitor",
                       position: (27, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n}\n",
                   position: (27, 36),
                  },
                 ],
                },
                position: (23, 54),
               },
               position: (23, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "fd_cfg",
                position: (29, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "director",
                  position: (29, 18),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\nMessages {\n  Name = Standard;\n  syslog = all, !skipped, !restored\n  ",
          position: (29, 28),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "fd_cfg",
            position: (34, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraMessagesConfig",
              position: (34, 18),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n",
          position: (34, 38),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sd_cfg",
        position: (38, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (38, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (38, 19),
        },
        Raw {
         content: "bacula-sd",
         position: (38, 28),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sd_conf",
        position: (39, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (39, 13),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (39, 18),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "bacula-sd.conf",
          position: (39, 29),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "Storage {\n  Name = \"",
          position: (41, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "sd_cfg",
            position: (42, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (42, 26),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\";\n  SDPort = ",
          position: (42, 31),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (43, 20),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "sd_cfg",
              position: (43, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (43, 36),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ";\n  WorkingDirectory = \"",
          position: (43, 41),
         },
         Expression {
          expression: Variable {
           identifier: "libDir",
           position: (44, 31),
          },
         },
         Raw {
          content: "\";\n  Pid Directory = \"/run\";\n  ",
          position: (44, 38),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "sd_cfg",
            position: (46, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraStorageConfig",
              position: (46, 18),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n\n",
          position: (46, 37),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (49, 9),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (49, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (49, 32),
             },
             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: "Autochanger {\n  Name = \"",
                   position: (50, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (51, 19),
                   },
                  },
                  Raw {
                   content: "\";\n  Device = ",
                   position: (51, 24),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (52, 20),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: ", ",
                        position: (52, 38),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "map",
                       position: (52, 43),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "a",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: String {
                         parts: [
                          Raw {
                           content: "\"",
                           position: (52, 52),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "a",
                            position: (52, 56),
                           },
                          },
                          Raw {
                           content: "\"",
                           position: (52, 58),
                          },
                         ],
                        },
                        position: (52, 48),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "value",
                         position: (52, 63),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "devices",
                           position: (52, 69),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ],
                   },
                  },
                  Raw {
                   content: ";\n  Changer Device =  \"",
                   position: (52, 78),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (53, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "changerDevice",
                       position: (53, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  Changer Command = \"",
                   position: (53, 50),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (54, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "changerCommand",
                       position: (54, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  ",
                   position: (54, 51),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (55, 11),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "extraAutochangerConfig",
                       position: (55, 17),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n}\n",
                   position: (55, 40),
                  },
                 ],
                },
                position: (49, 54),
               },
               position: (49, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "sd_cfg",
                position: (57, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "autochanger",
                  position: (57, 18),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\n",
          position: (57, 31),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (59, 9),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (59, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (59, 32),
             },
             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: "Device {\n  Name = \"",
                   position: (60, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (61, 19),
                   },
                  },
                  Raw {
                   content: "\";\n  Archive Device = \"",
                   position: (61, 24),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (62, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "archiveDevice",
                       position: (62, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  Media Type = \"",
                   position: (62, 49),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (63, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "mediaType",
                       position: (63, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  ",
                   position: (63, 41),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (64, 11),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "extraDeviceConfig",
                       position: (64, 17),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\n}\n",
                   position: (64, 35),
                  },
                 ],
                },
                position: (59, 54),
               },
               position: (59, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "sd_cfg",
                position: (66, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "device",
                  position: (66, 18),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\n",
          position: (66, 26),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (68, 9),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (68, 27),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (68, 32),
             },
             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: "Director {\n  Name = \"",
                   position: (69, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (70, 19),
                   },
                  },
                  Raw {
                   content: "\";\n  Password = \"",
                   position: (70, 24),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (71, 23),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "password",
                       position: (71, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n  Monitor = \"",
                   position: (71, 38),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "value",
                     position: (72, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "monitor",
                       position: (72, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "\";\n}\n",
                   position: (72, 36),
                  },
                 ],
                },
                position: (68, 54),
               },
               position: (68, 48),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "sd_cfg",
                position: (74, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "director",
                  position: (74, 18),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n\nMessages {\n  Name = Standard;\n  syslog = all, !skipped, !restored\n  ",
          position: (74, 28),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "sd_cfg",
            position: (79, 11),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraMessagesConfig",
              position: (79, 18),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n",
          position: (79, 38),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dir_cfg",
        position: (83, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (83, 13),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (83, 20),
        },
        Raw {
         content: "bacula-dir",
         position: (83, 29),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dir_conf",
        position: (84, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (84, 14),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (84, 19),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "bacula-dir.conf",
          position: (84, 30),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "Director {\n  Name = \"",
          position: (86, 1),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (87, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (87, 25),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\";\n  Password = \"",
          position: (87, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (88, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "password",
              position: (88, 29),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\";\n  DirPort = ",
          position: (88, 38),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (89, 19),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "dir_cfg",
              position: (89, 28),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (89, 36),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: ";\n  Working Directory = \"",
          position: (89, 41),
         },
         Expression {
          expression: Variable {
           identifier: "libDir",
           position: (90, 30),
          },
         },
         Raw {
          content: "\";\n  Pid Directory = \"/run/\";\n  QueryFile = \"",
          position: (90, 37),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (92, 22),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "bacula",
              position: (92, 27),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/etc/query.sql\";\n  ",
          position: (92, 34),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (93, 9),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraDirectorConfig",
              position: (93, 17),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n\nCatalog {\n  Name = \"PostgreSQL\";\n  dbname = \"bacula\";\n  user = \"bacula\";\n}\n\nMessages {\n  Name = Standard;\n  syslog = all, !skipped, !restored\n  ",
          position: (93, 37),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (105, 9),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraMessagesConfig",
              position: (105, 17),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n}\n\n",
          position: (105, 37),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (108, 7),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraConfig",
              position: (108, 15),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (108, 27),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "directorOptions",
        position: (111, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (113, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "password",
               position: (114, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (114, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (115, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (115, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (115, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (117, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the password that must be supplied for the default Bacula\nConsole to be authorized. The same password must appear in the\nDirector resource of the Console configuration file. For added\nsecurity, the password is never passed across the network but instead\na challenge response hash code created with the password. This\ndirective is required. If you have either /dev/random or bc on your\nmachine, Bacula will generate a random password during the\nconfiguration process, otherwise it will be left blank and you must\nmanually supply it.\n\nThe password is plain text. It is not generated through any special\nprocess but as noted above, it is better to use random text for\nsecurity reasons.\n",
                    position: (118, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (114, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "monitor",
               position: (134, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (134, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (135, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (135, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (135, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "no",
                        position: (135, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "yes",
                        position: (135, 35),
                       },
                      ],
                     },
                    ],
                    position: (135, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (136, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "no",
                    position: (136, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (137, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "yes",
                    position: (137, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (138, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If Monitor is set to <literal>no</literal>, this director will have\nfull access to this Storage daemon. If Monitor is set to\n<literal>yes</literal>, this director will only be able to fetch the\ncurrent status of this Storage daemon.\n\nPlease note that if this director is being used by a Monitor, we\nhighly recommend to set this directive to yes to avoid serious\nsecurity problems.\n",
                    position: (139, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (134, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (113, 15),
         },
        ),
       ],
       recursive: false,
       position: (112, 3),
      },
      position: (111, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "autochangerOptions",
        position: (152, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (154, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "changerDevice",
               position: (155, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (155, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (156, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (156, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (156, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (157, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The specified name-string must be the generic SCSI device name of the\nautochanger that corresponds to the normal read/write Archive Device\nspecified in the Device resource. This generic SCSI device name\nshould be specified if you have an autochanger or if you have a\nstandard tape drive and want to use the Alert Command (see below).\nFor example, on Linux systems, for an Archive Device name of\n<literal>/dev/nst0</literal>, you would specify\n<literal>/dev/sg0</literal> for the Changer Device name.  Depending\non your exact configuration, and the number of autochangers or the\ntype of autochanger, what you specify here can vary. This directive\nis optional. See the Using AutochangersAutochangersChapter chapter of\nthis manual for more details of using this and the following\nautochanger directives.\n",
                    position: (158, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (155, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "changerCommand",
               position: (174, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (174, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (175, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (175, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (175, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (176, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The name-string specifies an external program to be called that will\nautomatically change volumes as required by Bacula. Normally, this\ndirective will be specified only in the AutoChanger resource, which\nis then used for all devices. However, you may also specify the\ndifferent Changer Command in each Device resource. Most frequently,\nyou will specify the Bacula supplied mtx-changer script as follows:\n\n<literal>\"/path/mtx-changer %c %o %S %a %d\"</literal>\n\nand you will install the mtx on your system (found in the depkgs\nrelease). An example of this command is in the default bacula-sd.conf\nfile. For more details on the substitution characters that may be\nspecified to configure your autochanger please see the\nAutochangersAutochangersChapter chapter of this manual. For FreeBSD\nusers, you might want to see one of the several chio scripts in\nexamples/autochangers.\n",
                    position: (177, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (194, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/etc/bacula/mtx-changer %c %o %S %a %d",
                    position: (194, 20),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (174, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "devices",
               position: (197, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (197, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (198, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (199, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (199, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (199, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (199, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (199, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (197, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraAutochangerConfig",
               position: (202, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (202, 32),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (203, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (204, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (204, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (204, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (205, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Autochanger directive.\n",
                    position: (206, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (208, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "\n",
                    position: (209, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (202, 41),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (154, 15),
         },
        ),
       ],
       recursive: false,
       position: (153, 3),
      },
      position: (152, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "deviceOptions",
        position: (216, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (218, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "archiveDevice",
               position: (219, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (219, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (221, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (221, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (221, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (222, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The specified name-string gives the system file name of the storage\ndevice managed by this storage daemon. This will usually be the\ndevice file name of a removable storage device (tape drive), for\nexample <literal>/dev/nst0</literal> or\n<literal>/dev/rmt/0mbn</literal>. For a DVD-writer, it will be for\nexample <literal>/dev/hdc</literal>. It may also be a directory name\nif you are archiving to disk storage. In this case, you must supply\nthe full absolute path to the directory. When specifying a tape\ndevice, it is preferable that the \"non-rewind\" variant of the device\nfile name be given.\n",
                    position: (223, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (219, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mediaType",
               position: (236, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (236, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (238, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (238, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (238, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (239, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The specified name-string names the type of media supported by this\ndevice, for example, <literal>DLT7000</literal>. Media type names are\narbitrary in that you set them to anything you want, but they must be\nknown to the volume database to keep track of which storage daemons\ncan read which volumes. In general, each different storage type\nshould have a unique Media Type associated with it. The same\nname-string must appear in the appropriate Storage resource\ndefinition in the Director's configuration file.\n\nEven though the names you assign are arbitrary (i.e. you choose the\nname you want), you should take care in specifying them because the\nMedia Type is used to determine which storage device Bacula will\nselect during restore. Thus you should probably use the same Media\nType specification for all drives where the Media can be freely\ninterchanged. This is not generally an issue if you have a single\nStorage daemon, but it is with multiple Storage daemons, especially\nif they have incompatible media.\n\nFor example, if you specify a Media Type of <literal>DDS-4</literal>\nthen during the restore, Bacula will be able to choose any Storage\nDaemon that handles <literal>DDS-4</literal>. If you have an\nautochanger, you might want to name the Media Type in a way that is\nunique to the autochanger, unless you wish to possibly use the\nVolumes in other drives. You should also ensure to have unique Media\nType names if the Media is not compatible between drives. This\nspecification is required for all devices.\n\nIn addition, if you are using disk storage, each Device resource will\ngenerally have a different mount point or directory. In order for\nBacula to select the correct Device resource, each one must have a\nunique Media Type.\n",
                    position: (240, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (236, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraDeviceConfig",
               position: (274, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (274, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (275, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (276, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (276, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (276, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (277, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Device directive.\n",
                    position: (278, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (280, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "LabelMedia = yes\nRandom Access = no\nAutomaticMount = no\nRemovableMedia = no\nMaximumOpenWait = 60\nAlwaysOpen = no\n",
                    position: (281, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (274, 36),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (218, 15),
         },
        ),
       ],
       recursive: false,
       position: (217, 3),
      },
      position: (216, 19),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (293, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (294, 5),
           },
           Raw {
            content: "bacula-fd",
            position: (294, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (295, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (295, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (296, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (296, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (296, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (297, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (297, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (298, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable the Bacula File Daemon.\n",
                    position: (299, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (295, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (303, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (303, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (304, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (304, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "networking",
                        position: (304, 29),
                       },
                       Raw {
                        content: "hostName",
                        position: (304, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "-fd",
                    position: (304, 49),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (305, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (305, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (305, 43),
                     },
                     Raw {
                      content: "$",
                      position: (305, 44),
                     },
                     Raw {
                      content: "{config.networking.hostName}-fd\"",
                      position: (305, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (306, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (306, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (306, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (307, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The client name that must be used by the Director when connecting.\nGenerally, it is a good idea to use a name related to the machine so\nthat error messages can be easily identified if you have multiple\nClients. This directive is required.\n",
                    position: (308, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (303, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (315, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (315, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (316, 9),
                   },
                  ],
                 },
                 Int {
                  value: 9102,
                  position: (316, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (317, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (317, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (317, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (318, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This specifies the port number on which the Client listens for\nDirector connections. It must agree with the FDPort specified in\nthe Client resource of the Director's configuration file.\n",
                    position: (319, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (315, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "director",
               position: (325, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (325, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (326, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (326, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (327, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option defines director resources in Bacula File Daemon.\n",
                    position: (328, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (330, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (330, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (330, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (330, 37),
                     },
                     arguments: [
                      Variable {
                       identifier: "directorOptions",
                       position: (330, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (330, 16),
                 },
                ),
               ],
               recursive: false,
               position: (325, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraClientConfig",
               position: (333, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (333, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (334, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (335, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (335, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (335, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (336, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Client directive.\n",
                    position: (337, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (339, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum Concurrent Jobs = 20;\nHeartbeat Interval = 30;\n",
                    position: (340, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (333, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraMessagesConfig",
               position: (345, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (345, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (346, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (347, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (347, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (347, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (348, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Messages directive.\n",
                    position: (349, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (351, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "console = all\n",
                    position: (352, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (345, 38),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (294, 26),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (357, 5),
           },
           Raw {
            content: "bacula-sd",
            position: (357, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (358, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (358, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (359, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (359, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (359, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (360, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (360, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (361, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable Bacula Storage Daemon.\n",
                    position: (362, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (358, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (366, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (366, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (367, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (367, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "networking",
                        position: (367, 29),
                       },
                       Raw {
                        content: "hostName",
                        position: (367, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "-sd",
                    position: (367, 49),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (368, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (368, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (368, 43),
                     },
                     Raw {
                      content: "$",
                      position: (368, 44),
                     },
                     Raw {
                      content: "{config.networking.hostName}-sd\"",
                      position: (368, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (369, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (369, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (369, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (370, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the Name of the Storage daemon.\n",
                    position: (371, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (366, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (375, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (375, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (376, 9),
                   },
                  ],
                 },
                 Int {
                  value: 9103,
                  position: (376, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (377, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (377, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (377, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (378, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies port number on which the Storage daemon listens for\nDirector connections.\n",
                    position: (379, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (375, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "director",
               position: (384, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (384, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (385, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (385, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (386, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option defines Director resources in Bacula Storage Daemon.\n",
                    position: (387, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (389, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (389, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (389, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (389, 37),
                     },
                     arguments: [
                      Variable {
                       identifier: "directorOptions",
                       position: (389, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (389, 16),
                 },
                ),
               ],
               recursive: false,
               position: (384, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "device",
               position: (392, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (392, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (393, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (393, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (394, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option defines Device resources in Bacula Storage Daemon.\n",
                    position: (395, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (397, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (397, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (397, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (397, 37),
                     },
                     arguments: [
                      Variable {
                       identifier: "deviceOptions",
                       position: (397, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (397, 16),
                 },
                ),
               ],
               recursive: false,
               position: (392, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "autochanger",
               position: (400, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (400, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (401, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (401, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (402, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option defines Autochanger resources in Bacula Storage Daemon.\n",
                    position: (403, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (405, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (405, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (405, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (405, 37),
                     },
                     arguments: [
                      Variable {
                       identifier: "autochangerOptions",
                       position: (405, 47),
                      },
                     ],
                    },
                   ],
                  },
                  position: (405, 16),
                 },
                ),
               ],
               recursive: false,
               position: (400, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraStorageConfig",
               position: (408, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (408, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (409, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (410, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (410, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (410, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (411, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Storage directive.\n",
                    position: (412, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (414, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum Concurrent Jobs = 20;\nHeartbeat Interval = 30;\n",
                    position: (415, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (408, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraMessagesConfig",
               position: (420, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (420, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (421, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (422, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (422, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (422, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (423, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Messages directive.\n",
                    position: (424, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (426, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "console = all\n",
                    position: (427, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (420, 38),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (357, 26),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (433, 5),
           },
           Raw {
            content: "bacula-dir",
            position: (433, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (434, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (434, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (435, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (435, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (435, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (436, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (436, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (437, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable Bacula Director Daemon.\n",
                    position: (438, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (434, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (442, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (442, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (443, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (443, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "networking",
                        position: (443, 29),
                       },
                       Raw {
                        content: "hostName",
                        position: (443, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "-dir",
                    position: (443, 49),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (444, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (444, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (444, 43),
                     },
                     Raw {
                      content: "$",
                      position: (444, 44),
                     },
                     Raw {
                      content: "{config.networking.hostName}-dir\"",
                      position: (444, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (445, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (445, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (445, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (446, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The director name used by the system administrator. This directive is\nrequired.\n",
                    position: (447, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (442, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (452, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (452, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (453, 9),
                   },
                  ],
                 },
                 Int {
                  value: 9101,
                  position: (453, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (454, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (454, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (454, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (455, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specify the port (a positive integer) on which the Director daemon\nwill listen for Bacula Console connections. This same port number\nmust be specified in the Director resource of the Console\nconfiguration file. The default is 9101, so normally this directive\nneed not be specified. This directive should not be used if you\nspecify DirAddresses (N.B plural) directive.\n",
                    position: (456, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (452, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "password",
               position: (465, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (465, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (467, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (467, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (467, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (468, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the password that must be supplied for a Director.\n",
                    position: (469, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (465, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraMessagesConfig",
               position: (473, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (473, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (474, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (475, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (475, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (475, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (476, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Messages directive.\n",
                    position: (477, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (479, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "console = all\n",
                    position: (480, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (473, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraDirectorConfig",
               position: (484, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (484, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (485, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (486, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (486, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (486, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (487, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration to be passed in Director directive.\n",
                    position: (488, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (490, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum Concurrent Jobs = 20;\nHeartbeat Interval = 30;\n",
                    position: (491, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (484, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (496, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (496, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (497, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (498, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (498, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (498, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (499, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration for Bacula Director Daemon.\n",
                    position: (500, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (502, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "TODO\n",
                    position: (503, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (496, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (433, 27),
         },
        ),
       ],
       recursive: false,
       position: (293, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (509, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (509, 12),
       },
       arguments: [
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: LogicalOr,
           operands: [
            PropertyAccess {
             expression: Variable {
              identifier: "fd_cfg",
              position: (509, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable",
                position: (509, 25),
               },
              ],
             },
             default: None,
            },
            PropertyAccess {
             expression: Variable {
              identifier: "sd_cfg",
              position: (509, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "enable",
                position: (509, 42),
               },
              ],
             },
             default: None,
            },
           ],
           position: (509, 32),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "dir_cfg",
            position: (509, 52),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "enable",
              position: (509, 60),
             },
            ],
           },
           default: None,
          },
         ],
         position: (509, 49),
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (510, 5),
             },
             Raw {
              content: "services",
              position: (510, 13),
             },
             Raw {
              content: "bacula-fd",
              position: (510, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (510, 34),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "fd_cfg",
               position: (510, 39),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (510, 46),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (511, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (511, 18),
                    },
                   ],
                  },
                 ],
                 position: (511, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (512, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Bacula File Daemon",
                   position: (512, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (513, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "multi-user.target",
                     position: (513, 21),
                    },
                   ],
                  },
                 ],
                 position: (513, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (514, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (514, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bacula",
                      position: (514, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (514, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (515, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (516, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (516, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bacula",
                          position: (516, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/sbin/bacula-fd -f -u root -g bacula -c ",
                      position: (516, 36),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "fd_conf",
                       position: (516, 78),
                      },
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecReload",
                      position: (517, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (517, 25),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "coreutils",
                          position: (517, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/kill -HUP $MAINPID",
                      position: (517, 40),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "LogsDirectory",
                      position: (518, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (518, 26),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "StateDirectory",
                      position: (519, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (519, 27),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (515, 23),
                },
               ),
              ],
              recursive: false,
              position: (510, 53),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (523, 5),
             },
             Raw {
              content: "services",
              position: (523, 13),
             },
             Raw {
              content: "bacula-sd",
              position: (523, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (523, 34),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "sd_cfg",
               position: (523, 39),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (523, 46),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (524, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (524, 18),
                    },
                   ],
                  },
                 ],
                 position: (524, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (525, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Bacula Storage Daemon",
                   position: (525, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (526, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "multi-user.target",
                     position: (526, 21),
                    },
                   ],
                  },
                 ],
                 position: (526, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (527, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (527, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bacula",
                      position: (527, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (527, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (528, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (529, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (529, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bacula",
                          position: (529, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/sbin/bacula-sd -f -u bacula -g bacula -c ",
                      position: (529, 36),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "sd_conf",
                       position: (529, 80),
                      },
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecReload",
                      position: (530, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (530, 25),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "coreutils",
                          position: (530, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/kill -HUP $MAINPID",
                      position: (530, 40),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "LogsDirectory",
                      position: (531, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (531, 26),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "StateDirectory",
                      position: (532, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (532, 27),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (528, 23),
                },
               ),
              ],
              recursive: false,
              position: (523, 53),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (536, 5),
             },
             Raw {
              content: "postgresql",
              position: (536, 14),
             },
             Raw {
              content: "enable",
              position: (536, 25),
             },
            ],
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "dir_cfg",
               position: (536, 34),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (536, 42),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "true",
              position: (536, 52),
             },
            ],
            position: (536, 49),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (538, 5),
             },
             Raw {
              content: "services",
              position: (538, 13),
             },
             Raw {
              content: "bacula-dir",
              position: (538, 22),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (538, 35),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "dir_cfg",
               position: (538, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (538, 48),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "after",
                   position: (539, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "network.target",
                     position: (539, 18),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postgresql.service",
                     position: (539, 35),
                    },
                   ],
                  },
                 ],
                 position: (539, 15),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (540, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Bacula Director Daemon",
                   position: (540, 22),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wantedBy",
                   position: (541, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "multi-user.target",
                     position: (541, 21),
                    },
                   ],
                  },
                 ],
                 position: (541, 18),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (542, 7),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (542, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bacula",
                      position: (542, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (542, 14),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (543, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecStart",
                      position: (544, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (544, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bacula",
                          position: (544, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/sbin/bacula-dir -f -u bacula -g bacula -c ",
                      position: (544, 36),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "dir_conf",
                       position: (544, 81),
                      },
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "ExecReload",
                      position: (545, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (545, 25),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "coreutils",
                          position: (545, 30),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/kill -HUP $MAINPID",
                      position: (545, 40),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "LogsDirectory",
                      position: (546, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (546, 26),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "StateDirectory",
                      position: (547, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bacula",
                      position: (547, 27),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (543, 23),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "preStart",
                   position: (549, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "if ! test -e \"",
                   position: (550, 1),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "libDir",
                    position: (550, 25),
                   },
                  },
                  Raw {
                   content: "/db-created\"; then\n    ",
                   position: (550, 32),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (551, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "postgresql",
                       position: (551, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/createuser --no-superuser --no-createdb --no-createrole bacula\n    #",
                   position: (551, 31),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (552, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "postgresql",
                       position: (552, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/createdb --owner bacula bacula\n\n    # populate DB\n    ",
                   position: (552, 32),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (555, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bacula",
                       position: (555, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/etc/create_bacula_database postgresql\n    ",
                   position: (555, 27),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (556, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bacula",
                       position: (556, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/etc/make_bacula_tables postgresql\n    ",
                   position: (556, 27),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (557, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bacula",
                       position: (557, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/etc/grant_bacula_privileges postgresql\n    touch \"",
                   position: (557, 27),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "libDir",
                    position: (558, 22),
                   },
                  },
                  Raw {
                   content: "/db-created\"\nelse\n    ",
                   position: (558, 29),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (560, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bacula",
                       position: (560, 20),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/etc/update_bacula_tables postgresql || true\nfi\n",
                   position: (560, 27),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (538, 55),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (565, 5),
             },
             Raw {
              content: "systemPackages",
              position: (565, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (565, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "bacula",
                 position: (565, 41),
                },
               ],
              },
              default: None,
             },
            ],
            position: (565, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (567, 5),
             },
             Raw {
              content: "users",
              position: (567, 11),
             },
             Raw {
              content: "bacula",
              position: (567, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (568, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "bacula",
                 position: (568, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (569, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (569, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (569, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (569, 24),
                 },
                 Raw {
                  content: "bacula",
                  position: (569, 29),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (570, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: Variable {
                  identifier: "libDir",
                  position: (570, 17),
                 },
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (571, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (571, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (572, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Bacula Daemons user",
                 position: (572, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "shell",
                 position: (573, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (573, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bash",
                     position: (573, 23),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/bash",
                 position: (573, 28),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (567, 26),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (576, 5),
             },
             Raw {
              content: "groups",
              position: (576, 11),
             },
             Raw {
              content: "bacula",
              position: (576, 18),
             },
             Raw {
              content: "gid",
              position: (576, 25),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (576, 31),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (576, 38),
              },
              Raw {
               content: "gids",
               position: (576, 42),
              },
              Raw {
               content: "bacula",
               position: (576, 47),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         recursive: false,
         position: (509, 68),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (292, 4),
   },
   position: (9, 1),
  },
  position: (7, 1),
 },
 position: (1, 1),
}