---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "home-assistant",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "format",
        position: (7, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (7, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "formats",
          position: (7, 17),
         },
         Raw {
          content: "yaml",
          position: (7, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [],
        recursive: false,
        position: (7, 30),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "filteredConfig",
        position: (14, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (14, 20),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "converge",
          position: (14, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (14, 34),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "filterAttrsRecursive",
            position: (14, 38),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Function {
          argument: Some(
           "_",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: UnaryOperation {
            operator: Not,
            operand: FunctionApplication {
             function: Variable {
              identifier: "elem",
              position: (14, 68),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (14, 73),
              },
              List {
               elements: [
                Variable {
                 identifier: "null",
                 position: (14, 77),
                },
               ],
               position: (14, 75),
              },
             ],
            },
            position: (14, 66),
           },
           position: (14, 63),
          },
          position: (14, 60),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (14, 86),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "config",
           position: (14, 90),
          },
         ],
        },
        default: Some(
         Map {
          bindings: [],
          recursive: false,
          position: (14, 100),
         },
        ),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configFile",
        position: (15, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (15, 16),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "runCommand",
          position: (15, 21),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "configuration.yaml",
          position: (15, 33),
         },
        ],
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "preferLocalBuild",
             position: (15, 55),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (15, 74),
          },
         ),
        ],
        recursive: false,
        position: (15, 53),
       },
       String {
        parts: [
         Raw {
          content: "cp ",
          position: (16, 1),
         },
         Expression {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "format",
             position: (16, 10),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "generate",
               position: (16, 17),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "configuration.yaml",
               position: (16, 27),
              },
             ],
            },
            Variable {
             identifier: "filteredConfig",
             position: (16, 47),
            },
           ],
          },
         },
         Raw {
          content: " $out\nsed -i -e \"s/'\\!\\([a-z_]\\+\\) \\(.*\\)'/\\!\\1 \\2/;s/^\\!\\!/\\!/;\" $out\n",
          position: (16, 62),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "lovelaceConfig",
        position: (19, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (19, 20),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "lovelaceConfig",
         position: (19, 24),
        },
       ],
      },
      default: Some(
       Map {
        bindings: [],
        recursive: false,
        position: (19, 42),
       },
      ),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "lovelaceConfigFile",
        position: (20, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "format",
        position: (20, 24),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "generate",
          position: (20, 31),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "ui-lovelace.yaml",
          position: (20, 41),
         },
        ],
       },
       Variable {
        identifier: "lovelaceConfig",
        position: (20, 59),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "availableComponents",
        position: (23, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (23, 25),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (23, 29),
        },
        Raw {
         content: "availableComponents",
         position: (23, 37),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "explicitComponents",
        position: (26, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (26, 24),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (26, 28),
        },
        Raw {
         content: "extraComponents",
         position: (26, 36),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useExplicitComponent",
        position: (27, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "component",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "elem",
        position: (27, 37),
       },
       arguments: [
        Variable {
         identifier: "component",
         position: (27, 42),
        },
        Variable {
         identifier: "explicitComponents",
         position: (27, 52),
        },
       ],
      },
      position: (27, 26),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usedPlatforms",
        position: (37, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "config",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: FunctionApplication {
        function: Variable {
         identifier: "isAttrs",
         position: (38, 8),
        },
        arguments: [
         Variable {
          identifier: "config",
          position: (38, 16),
         },
        ],
       },
       then: BinaryOperation {
        operator: Concatenation,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "optional",
           position: (39, 7),
          },
          arguments: [
           HasProperty {
            expression: Variable {
             identifier: "config",
             position: (39, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "platform",
               position: (39, 26),
              },
             ],
            },
            position: (39, 24),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (39, 36),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "platform",
               position: (39, 43),
              },
             ],
            },
            default: None,
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "concatMap",
           position: (40, 10),
          },
          arguments: [
           Variable {
            identifier: "usedPlatforms",
            position: (40, 20),
           },
           FunctionApplication {
            function: Variable {
             identifier: "attrValues",
             position: (40, 35),
            },
            arguments: [
             Variable {
              identifier: "config",
              position: (40, 46),
             },
            ],
           },
          ],
         },
        ],
        position: (40, 7),
       },
       else_: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isList",
          position: (41, 13),
         },
         arguments: [
          Variable {
           identifier: "config",
           position: (41, 20),
          },
         ],
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "concatMap",
          position: (42, 7),
         },
         arguments: [
          Variable {
           identifier: "usedPlatforms",
           position: (42, 17),
          },
          Variable {
           identifier: "config",
           position: (42, 31),
          },
         ],
        },
        else_: List {
         elements: [],
         position: (43, 10),
        },
        position: (41, 10),
       },
       position: (38, 5),
      },
      position: (37, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useComponentPlatform",
        position: (45, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "component",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "elem",
        position: (45, 37),
       },
       arguments: [
        Variable {
         identifier: "component",
         position: (45, 42),
        },
        FunctionApplication {
         function: Variable {
          identifier: "usedPlatforms",
          position: (45, 53),
         },
         arguments: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (45, 67),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (45, 71),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ],
      },
      position: (45, 26),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useComponent",
        position: (49, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "component",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: LogicalOr,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "hasAttrByPath",
              position: (50, 5),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "splitString",
                position: (50, 20),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: ".",
                   position: (50, 33),
                  },
                 ],
                },
                Variable {
                 identifier: "component",
                 position: (50, 36),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (50, 47),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "config",
                  position: (50, 51),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "useComponentPlatform",
              position: (51, 8),
             },
             arguments: [
              Variable {
               identifier: "component",
               position: (51, 29),
              },
             ],
            },
           ],
           position: (51, 5),
          },
          FunctionApplication {
           function: Variable {
            identifier: "useExplicitComponent",
            position: (52, 8),
           },
           arguments: [
            Variable {
             identifier: "component",
             position: (52, 29),
            },
           ],
          },
         ],
         position: (52, 5),
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "builtins",
           position: (53, 8),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "elem",
             position: (53, 17),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "component",
           position: (53, 22),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (53, 32),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "extraComponents",
              position: (53, 36),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ],
       position: (53, 5),
      },
      position: (49, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "extraComponents",
        position: (56, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "filter",
       position: (56, 21),
      },
      arguments: [
       Variable {
        identifier: "useComponent",
        position: (56, 28),
       },
       Variable {
        identifier: "availableComponents",
        position: (56, 41),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "package",
        position: (58, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (58, 14),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "package",
          position: (58, 18),
         },
         Raw {
          content: "override",
          position: (58, 26),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Function {
        argument: Some(
         "oldArgs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "extraComponents",
              position: (61, 5),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "oldArgs",
               position: (61, 23),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "extraComponents",
                 position: (61, 31),
                },
               ],
              },
              default: Some(
               List {
                elements: [],
                position: (61, 50),
               },
              ),
             },
             Variable {
              identifier: "extraComponents",
              position: (61, 56),
             },
            ],
            position: (61, 53),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "extraPackages",
              position: (62, 5),
             },
            ],
           },
           Function {
            argument: Some(
             "ps",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: Concatenation,
             operands: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "oldArgs",
                 position: (62, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraPackages",
                   position: (62, 34),
                  },
                 ],
                },
                default: Some(
                 Function {
                  argument: Some(
                   "_",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: List {
                   elements: [],
                   position: (62, 55),
                  },
                  position: (62, 52),
                 },
                ),
               },
               arguments: [
                Variable {
                 identifier: "ps",
                 position: (62, 59),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (62, 67),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraPackages",
                   position: (62, 71),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "ps",
                 position: (62, 85),
                },
               ],
              },
             ],
             position: (62, 63),
            },
            position: (62, 21),
           },
          ),
         ],
         recursive: false,
         position: (58, 45),
        },
        position: (58, 36),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (65, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (67, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (67, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "home-assistant",
               position: (67, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "applyDefaultConfig",
               position: (67, 59),
              },
             ],
            },
           ],
           position: (67, 28),
          },
          String {
           parts: [
            Raw {
             content: "The default config was migrated into services.home-assistant.config",
             position: (67, 82),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (68, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (68, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "home-assistant",
               position: (68, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "autoExtraComponents",
               position: (68, 59),
              },
             ],
            },
           ],
           position: (68, 28),
          },
          String {
           parts: [
            Raw {
             content: "Components are now parsed from services.home-assistant.config unconditionally",
             position: (68, 83),
            },
           ],
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (69, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (69, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "home-assistant",
               position: (69, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "port",
               position: (69, 59),
              },
             ],
            },
           ],
           position: (69, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (69, 70),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "home-assistant",
               position: (69, 81),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "config",
               position: (69, 98),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "http",
               position: (69, 107),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "server_port",
               position: (69, 114),
              },
             ],
            },
           ],
           position: (69, 67),
          },
         ],
        },
       ],
       position: (65, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (72, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "buildDocsInSandbox",
            position: (73, 5),
           },
          ],
         },
         Variable {
          identifier: "false",
          position: (73, 26),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "maintainers",
            position: (74, 5),
           },
          ],
         },
         PropertyAccess {
          expression: Variable {
           identifier: "teams",
           position: (74, 19),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "home-assistant",
             position: (74, 25),
            },
            Raw {
             content: "members",
             position: (74, 40),
            },
           ],
          },
          default: None,
         },
        ),
       ],
       recursive: false,
       position: (72, 10),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (77, 3),
        },
        Raw {
         content: "services",
         position: (77, 11),
        },
        Raw {
         content: "home-assistant",
         position: (77, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (80, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (80, 14),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "Home Assistant. Please note that this installation method is unsupported upstream",
              position: (80, 30),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "configDir",
            position: (82, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (82, 17),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (83, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/lib/hass",
                 position: (83, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (84, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (84, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (84, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (85, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The config directory, where your <filename>configuration.yaml</filename> is located.",
                 position: (85, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (82, 26),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "extraComponents",
            position: (88, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (88, 23),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (89, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (89, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "listOf",
                   position: (89, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (89, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "enum",
                     position: (89, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Variable {
                   identifier: "availableComponents",
                   position: (89, 39),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (90, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "default_config",
                     position: (92, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "met",
                     position: (93, 10),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "esphome",
                     position: (94, 10),
                    },
                   ],
                  },
                 ],
                 position: (90, 17),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionals",
                  position: (95, 12),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: LogicalOr,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (95, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stdenv",
                        position: (95, 28),
                       },
                       Raw {
                        content: "hostPlatform",
                        position: (95, 35),
                       },
                       Raw {
                        content: "isAarch32",
                        position: (95, 48),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (95, 61),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "stdenv",
                        position: (95, 66),
                       },
                       Raw {
                        content: "hostPlatform",
                        position: (95, 73),
                       },
                       Raw {
                        content: "isAarch64",
                        position: (95, 86),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (95, 58),
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "rpi_power",
                       position: (98, 10),
                      },
                     ],
                    },
                   ],
                   position: (95, 97),
                  },
                 ],
                },
               ],
               position: (95, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (100, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (100, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "[\n  \"analytics\"\n  \"default_config\"\n  \"esphome\"\n  \"my\"\n  \"shopping_list\"\n  \"wled\"\n]\n",
                   position: (101, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (110, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "List of <link xlink:href=\"https://www.home-assistant.io/integrations/\">components</link> that have their dependencies included in the package.\n\nThe component name can be found in the URL, for example <literal>https://www.home-assistant.io/integrations/ffmpeg/</literal> would map to <literal>ffmpeg</literal>.\n",
                 position: (111, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (88, 32),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "extraPackages",
            position: (117, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (117, 21),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (118, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (118, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "functionTo",
                   position: (118, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (118, 32),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "listOf",
                     position: (118, 38),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (118, 45),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "package",
                      position: (118, 51),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (119, 7),
                },
               ],
              },
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: List {
                elements: [],
                position: (119, 20),
               },
               position: (119, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (120, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (120, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "python3Packages: with python3Packages; [];\n",
                   position: (121, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (123, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (123, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "python3Packages: with python3Packages; [\n  # postgresql support\n  psycopg2\n];\n",
                   position: (124, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (129, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "List of packages to add to propagatedBuildInputs.\n\nA popular example is <package>python3Packages.psycopg2</package>\nfor PostgreSQL support in the recorder component.\n",
                 position: (130, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (117, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (137, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (137, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (138, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (138, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nullOr",
                   position: (138, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (138, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "submodule",
                     position: (138, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "freeformType",
                        position: (139, 9),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "format",
                       position: (139, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (139, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (140, 9),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "homeassistant",
                           position: (145, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "name",
                              position: (147, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (147, 20),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (148, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (148, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (148, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (148, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (148, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (149, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (149, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (150, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Home",
                                   position: (150, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (151, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Name of the location where Home Assistant is running.\n",
                                   position: (152, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (147, 29),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "latitude",
                              position: (156, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (156, 24),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (157, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (157, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (157, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (157, 36),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "either",
                                       position: (157, 42),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (157, 49),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "float",
                                        position: (157, 55),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (157, 61),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "str",
                                        position: (157, 67),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (158, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (158, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (159, 15),
                                  },
                                 ],
                                },
                                Float {
                                 value: 52.3,
                                 position: (159, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (160, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Latitude of your location required to calculate the time the sun rises and sets.\n",
                                   position: (161, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (156, 33),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "longitude",
                              position: (165, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (165, 25),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (166, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (166, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (166, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (166, 36),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "either",
                                       position: (166, 42),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (166, 49),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "float",
                                        position: (166, 55),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (166, 61),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "str",
                                        position: (166, 67),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (167, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (167, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (168, 15),
                                  },
                                 ],
                                },
                                Float {
                                 value: 4.9,
                                 position: (168, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (169, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Longitude of your location required to calculate the time the sun rises and sets.\n",
                                   position: (170, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (165, 34),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "unit_system",
                              position: (174, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (174, 27),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (175, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (175, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (175, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (175, 36),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "enum",
                                       position: (175, 42),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    List {
                                     elements: [
                                      String {
                                       parts: [
                                        Raw {
                                         content: "metric",
                                         position: (175, 50),
                                        },
                                       ],
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "imperial",
                                         position: (175, 59),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (175, 47),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (176, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (176, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (177, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "metric",
                                   position: (177, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (178, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The unit system to use. This also sets temperature_unit, Celsius for Metric and Fahrenheit for Imperial.\n",
                                   position: (179, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (174, 36),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "temperature_unit",
                              position: (183, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (183, 32),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (184, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (184, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (184, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (184, 36),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "enum",
                                       position: (184, 42),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    List {
                                     elements: [
                                      String {
                                       parts: [
                                        Raw {
                                         content: "C",
                                         position: (184, 50),
                                        },
                                       ],
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "F",
                                         position: (184, 54),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (184, 47),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (185, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (185, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (186, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "C",
                                   position: (186, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (187, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Override temperature unit set by unit_system. <literal>C</literal> for Celsius, <literal>F</literal> for Fahrenheit.\n",
                                   position: (188, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (183, 41),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "time_zone",
                              position: (192, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (192, 25),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (193, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (193, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (193, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (193, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (193, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (194, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "config",
                                  position: (194, 25),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "time",
                                    position: (194, 32),
                                   },
                                   Raw {
                                    content: "timeZone",
                                    position: (194, 37),
                                   },
                                  ],
                                 },
                                 default: Some(
                                  Variable {
                                   identifier: "null",
                                   position: (194, 49),
                                  },
                                 ),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "defaultText",
                                   position: (195, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "literalExpression",
                                  position: (195, 29),
                                 },
                                 arguments: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "config.time.timeZone or null\n",
                                     position: (196, 1),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (198, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Europe/Amsterdam",
                                   position: (198, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (199, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Pick your time zone from the column TZ of Wikipedia’s <link xlink:href=\"https://en.wikipedia.org/wiki/List_of_tz_database_time_zones\">list of tz database time zones</link>.\n",
                                   position: (200, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (192, 34),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (145, 27),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "http",
                           position: (205, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "server_host",
                              position: (207, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (207, 27),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (208, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (208, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "either",
                                     position: (208, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (208, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (208, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (208, 46),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "listOf",
                                       position: (208, 52),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (208, 59),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "str",
                                        position: (208, 65),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (209, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "0.0.0.0",
                                     position: (210, 18),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "::",
                                     position: (211, 18),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (209, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (213, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "::1",
                                   position: (213, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (214, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Only listen to incoming requests on specific IP/host. The default listed assumes support for IPv4 and IPv6.\n",
                                   position: (215, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (207, 36),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "server_port",
                              position: (219, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (219, 27),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (220, 15),
                                  },
                                 ],
                                },
                                Int {
                                 value: 8123,
                                 position: (220, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (221, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (221, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "port",
                                    position: (221, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (222, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The port on which to listen.\n",
                                   position: (223, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (219, 36),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (205, 18),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "lovelace",
                           position: (228, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "mode",
                              position: (230, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (230, 20),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (231, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (231, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "enum",
                                     position: (231, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  List {
                                   elements: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "yaml",
                                       position: (231, 36),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "storage",
                                       position: (231, 43),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (231, 33),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (232, 15),
                                  },
                                 ],
                                },
                                IfThenElse {
                                 predicate: BinaryOperation {
                                  operator: NotEqualTo,
                                  operands: [
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (232, 28),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "lovelaceConfig",
                                       position: (232, 32),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   Variable {
                                    identifier: "null",
                                    position: (232, 50),
                                   },
                                  ],
                                  position: (232, 47),
                                 },
                                 then: String {
                                  parts: [
                                   Raw {
                                    content: "yaml",
                                    position: (233, 23),
                                   },
                                  ],
                                 },
                                 else_: String {
                                  parts: [
                                   Raw {
                                    content: "storage",
                                    position: (234, 23),
                                   },
                                  ],
                                 },
                                 position: (232, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "defaultText",
                                   position: (235, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "literalExpression",
                                  position: (235, 29),
                                 },
                                 arguments: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "if cfg.lovelaceConfig != null\n  then \"yaml\"\nelse \"storage\";\n",
                                     position: (236, 1),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (240, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "yaml",
                                   position: (240, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (241, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "In what mode should the main Lovelace panel be, <literal>yaml</literal> or <literal>storage</literal> (UI managed).\n",
                                   position: (242, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (230, 29),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (228, 22),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (140, 19),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (138, 44),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (248, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (248, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "{\n  homeassistant = {\n    name = \"Home\";\n    latitude = \"!secret latitude\";\n    longitude = \"!secret longitude\";\n    elevation = \"!secret elevation\";\n    unit_system = \"metric\";\n    time_zone = \"UTC\";\n  };\n  frontend = {\n    themes = \"!include_dir_merge_named themes\";\n  };\n  http = {};\n  feedreader.urls = [ \"https://nixos.org/blogs.xml\" ];\n}\n",
                   position: (249, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (265, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Your <filename>configuration.yaml</filename> as a Nix attribute set.\n\nYAML functions like <link xlink:href=\"https://www.home-assistant.io/docs/configuration/secrets/\">secrets</link>\ncan be passed as a string and will be unquoted automatically.\n\nUnless this option is explicitly set to <literal>null</literal>\nwe assume your <filename>configuration.yaml</filename> is\nmanaged through this module and thereby overwritten on startup.\n",
                 position: (266, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (137, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "configWritable",
            position: (277, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (277, 22),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (278, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (278, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (279, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (279, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (279, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (280, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether to make <filename>configuration.yaml</filename> writable.\n\nThis will allow you to edit it from Home Assistant's web interface.\n\nThis only has an effect if <option>config</option> is set.\nHowever, bear in mind that it will be overwritten at every start of the service.\n",
                 position: (281, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (277, 31),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "lovelaceConfig",
            position: (290, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (290, 22),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (291, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (291, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (292, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (292, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nullOr",
                   position: (292, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "format",
                  position: (292, 27),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (292, 34),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (294, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (294, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "{\n  title = \"My Awesome Home\";\n  views = [ {\n    title = \"Example\";\n    cards = [ {\n      type = \"markdown\";\n      title = \"Lovelace\";\n      content = \"Welcome to your **Lovelace UI**.\";\n    } ];\n  } ];\n}\n",
                   position: (295, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (307, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Your <filename>ui-lovelace.yaml</filename> as a Nix attribute set.\nSetting this option will automatically set <literal>lovelace.mode</literal> to <literal>yaml</literal>.\n\nBeware that setting this option will delete your previous <filename>ui-lovelace.yaml</filename>\n",
                 position: (308, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (290, 31),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "lovelaceConfigWritable",
            position: (315, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (315, 30),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (316, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (316, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (317, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (317, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (317, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (318, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether to make <filename>ui-lovelace.yaml</filename> writable.\n\nThis will allow you to edit it from Home Assistant's web interface.\n\nThis only has an effect if <option>lovelaceConfig</option> is set.\nHowever, bear in mind that it will be overwritten at every start of the service.\n",
                 position: (319, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (315, 39),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "package",
            position: (328, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (328, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (329, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (329, 17),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "home-assistant",
                   position: (329, 22),
                  },
                  Raw {
                   content: "overrideAttrs",
                   position: (329, 37),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Function {
                 argument: Some(
                  "oldAttrs",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "doInstallCheck",
                       position: (330, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (330, 26),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (329, 62),
                 },
                 position: (329, 52),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (332, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (332, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "pkgs.home-assistant.overrideAttrs (oldAttrs: {\n  doInstallCheck = false;\n})\n",
                   position: (333, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (337, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (337, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (337, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (338, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (338, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "pkgs.home-assistant.override {\n  extraPackages = python3Packages: with python3Packages; [\n    psycopg2\n  ];\n  extraComponents = [\n    \"default_config\"\n    \"esphome\"\n    \"met\"\n  ];\n}\n",
                   position: (339, 1),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (350, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The Home Assistant package to use.\n",
                 position: (351, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (328, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "openFirewall",
            position: (355, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (355, 20),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (356, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (356, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (357, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (357, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (357, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (358, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether to open the firewall for the specified port.",
                 position: (358, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (355, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (77, 37),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (362, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (362, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (362, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (362, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "networking",
              position: (363, 5),
             },
             Raw {
              content: "firewall",
              position: (363, 16),
             },
             Raw {
              content: "allowedTCPPorts",
              position: (363, 25),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (363, 43),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (363, 48),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "openFirewall",
                 position: (363, 52),
                },
               ],
              },
              default: None,
             },
             List {
              elements: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (363, 67),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "port",
                   position: (363, 71),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (363, 65),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (365, 5),
             },
             Raw {
              content: "services",
              position: (365, 13),
             },
             Raw {
              content: "home-assistant",
              position: (365, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (366, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Home Assistant",
                 position: (366, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (367, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "network-online.target",
                   position: (368, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mysql.service",
                   position: (371, 10),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "postgresql.service",
                   position: (372, 10),
                  },
                 ],
                },
               ],
               position: (367, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (374, 7),
                },
               ],
              },
              LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "copyConfig",
                    position: (375, 9),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (375, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "configWritable",
                      position: (375, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "cp --no-preserve=mode ",
                     position: (376, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "configFile",
                      position: (376, 35),
                     },
                    },
                    Raw {
                     content: " \"",
                     position: (376, 46),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (376, 50),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (376, 54),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/configuration.yaml\"\n",
                     position: (376, 64),
                    },
                   ],
                  },
                  else_: String {
                   parts: [
                    Raw {
                     content: "rm -f \"",
                     position: (378, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (378, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (378, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/configuration.yaml\"\nln -s ",
                     position: (378, 34),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "configFile",
                      position: (379, 19),
                     },
                    },
                    Raw {
                     content: " \"",
                     position: (379, 30),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (379, 34),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (379, 38),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/configuration.yaml\"\n",
                     position: (379, 48),
                    },
                   ],
                  },
                  position: (375, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "copyLovelaceConfig",
                    position: (381, 9),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (381, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "lovelaceConfigWritable",
                      position: (381, 37),
                     },
                    ],
                   },
                   default: None,
                  },
                  then: String {
                   parts: [
                    Raw {
                     content: "cp --no-preserve=mode ",
                     position: (382, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "lovelaceConfigFile",
                      position: (382, 35),
                     },
                    },
                    Raw {
                     content: " \"",
                     position: (382, 54),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (382, 58),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (382, 62),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/ui-lovelace.yaml\"\n",
                     position: (382, 72),
                    },
                   ],
                  },
                  else_: String {
                   parts: [
                    Raw {
                     content: "rm -f \"",
                     position: (384, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (384, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (384, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/ui-lovelace.yaml\"\nln -s ",
                     position: (384, 34),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "lovelaceConfigFile",
                      position: (385, 19),
                     },
                    },
                    Raw {
                     content: " \"",
                     position: (385, 38),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (385, 42),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (385, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/ui-lovelace.yaml\"\n",
                     position: (385, 56),
                    },
                   ],
                  },
                  position: (381, 30),
                 },
                ),
               ],
               target: BinaryOperation {
                operator: Addition,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (388, 10),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (388, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "config",
                         position: (388, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (388, 40),
                     },
                    ],
                    position: (388, 37),
                   },
                   Variable {
                    identifier: "copyConfig",
                    position: (388, 46),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (389, 10),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (389, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lovelaceConfig",
                         position: (389, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (389, 48),
                     },
                    ],
                    position: (389, 45),
                   },
                   Variable {
                    identifier: "copyLovelaceConfig",
                    position: (389, 54),
                   },
                  ],
                 },
                ],
                position: (388, 58),
               },
               position: (374, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (391, 7),
                },
               ],
              },
              LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "capabilities",
                    position: (393, 9),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   List {
                    elements: [
                     String {
                      parts: [],
                     },
                    ],
                    position: (393, 24),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "unique",
                     position: (397, 15),
                    },
                    arguments: [
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (397, 23),
                        },
                        arguments: [
                         BinaryOperation {
                          operator: LogicalOr,
                          operands: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "useComponent",
                             position: (397, 34),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "bluetooth_tracker",
                                position: (397, 48),
                               },
                              ],
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "useComponent",
                             position: (397, 70),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "bluetooth_le_tracker",
                                position: (397, 84),
                               },
                              ],
                             },
                            ],
                           },
                          ],
                          position: (397, 67),
                         },
                         List {
                          elements: [
                           String {
                            parts: [
                             Raw {
                              content: "CAP_NET_ADMIN",
                              position: (400, 12),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "CAP_NET_RAW",
                              position: (401, 12),
                             },
                            ],
                           },
                          ],
                          position: (397, 107),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "lib",
                            position: (402, 14),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "optionals",
                              position: (402, 18),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "useComponent",
                             position: (402, 29),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "emulated_hue",
                                position: (402, 43),
                               },
                              ],
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "CAP_NET_BIND_SERVICE",
                                position: (405, 12),
                               },
                              ],
                             },
                            ],
                            position: (402, 58),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: PropertyAccess {
                           expression: Variable {
                            identifier: "lib",
                            position: (406, 14),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "optionals",
                              position: (406, 18),
                             },
                            ],
                           },
                           default: None,
                          },
                          arguments: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "useComponent",
                             position: (406, 29),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "nmap_tracker",
                                position: (406, 43),
                               },
                              ],
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "CAP_NET_ADMIN",
                                position: (408, 12),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "CAP_NET_BIND_SERVICE",
                                position: (409, 12),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "CAP_NET_RAW",
                                position: (410, 12),
                               },
                              ],
                             },
                            ],
                            position: (406, 58),
                           },
                          ],
                         },
                        ],
                        position: (406, 11),
                       },
                      ],
                      position: (402, 11),
                     },
                    ],
                   },
                  ],
                  position: (397, 11),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "componentsUsingBluetooth",
                    position: (412, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "bluetooth_tracker",
                      position: (414, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "bluetooth_le_tracker",
                      position: (415, 12),
                     },
                    ],
                   },
                  ],
                  position: (412, 36),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "componentsUsingPing",
                    position: (417, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "ping",
                      position: (419, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "wake_on_lan",
                      position: (420, 12),
                     },
                    ],
                   },
                  ],
                  position: (417, 31),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "componentsUsingSerialDevices",
                    position: (422, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "acer_projector",
                      position: (430, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "alarmdecoder",
                      position: (431, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "arduino",
                      position: (432, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "blackbird",
                      position: (433, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "deconz",
                      position: (434, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "dsmr",
                      position: (435, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "edl21",
                      position: (436, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "elkm1",
                      position: (437, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "elv",
                      position: (438, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "enocean",
                      position: (439, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "firmata",
                      position: (440, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "flexit",
                      position: (441, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "gpsd",
                      position: (442, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "insteon",
                      position: (443, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "kwb",
                      position: (444, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "lacrosse",
                      position: (445, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mhz19",
                      position: (446, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "modbus",
                      position: (447, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "modem_callerid",
                      position: (448, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "mysensors",
                      position: (449, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "nad",
                      position: (450, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "numato",
                      position: (451, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "rflink",
                      position: (452, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "rfxtrx",
                      position: (453, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "scsgate",
                      position: (454, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "serial",
                      position: (455, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "serial_pm",
                      position: (456, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "sms",
                      position: (457, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "upb",
                      position: (458, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "usb",
                      position: (459, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "velbus",
                      position: (460, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "w800rf32",
                      position: (461, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "xbee",
                      position: (462, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "zha",
                      position: (463, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "zwave",
                      position: (464, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "zwave_js",
                      position: (465, 12),
                     },
                    ],
                   },
                  ],
                  position: (422, 40),
                 },
                ),
               ],
               target: Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ExecStart",
                     position: (468, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "package",
                      position: (468, 24),
                     },
                    },
                    Raw {
                     content: "/bin/hass --config '",
                     position: (468, 32),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (468, 54),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "configDir",
                         position: (468, 58),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "'",
                     position: (468, 68),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ExecReload",
                     position: (469, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (469, 25),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "coreutils",
                         position: (469, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/kill -HUP $MAINPID",
                     position: (469, 40),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "User",
                     position: (470, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hass",
                     position: (470, 17),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "Group",
                     position: (471, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "hass",
                     position: (471, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "Restart",
                     position: (472, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "on-failure",
                     position: (472, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RestartForceExitStatus",
                     position: (473, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "100",
                     position: (473, 35),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "SuccessExitStatus",
                     position: (474, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "100",
                     position: (474, 30),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "KillSignal",
                     position: (475, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "SIGINT",
                     position: (475, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "AmbientCapabilities",
                     position: (478, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "capabilities",
                   position: (478, 31),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "CapabilityBoundingSet",
                     position: (479, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "capabilities",
                   position: (479, 33),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "DeviceAllow",
                     position: (480, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionals",
                    position: (480, 24),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "any",
                      position: (480, 35),
                     },
                     arguments: [
                      Variable {
                       identifier: "useComponent",
                       position: (480, 39),
                      },
                      Variable {
                       identifier: "componentsUsingSerialDevices",
                       position: (480, 52),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "char-ttyACM rw",
                         position: (481, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "char-ttyAMA rw",
                         position: (482, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "char-ttyUSB rw",
                         position: (483, 12),
                        },
                       ],
                      },
                     ],
                     position: (480, 82),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "DevicePolicy",
                     position: (485, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "closed",
                     position: (485, 25),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "LockPersonality",
                     position: (486, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (486, 27),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "MemoryDenyWriteExecute",
                     position: (487, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (487, 34),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "NoNewPrivileges",
                     position: (488, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (488, 27),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "PrivateTmp",
                     position: (489, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (489, 22),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "PrivateUsers",
                     position: (490, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (490, 24),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectClock",
                     position: (491, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (491, 24),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectControlGroups",
                     position: (492, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (492, 32),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectHome",
                     position: (493, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (493, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectHostname",
                     position: (494, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (494, 27),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectKernelLogs",
                     position: (495, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (495, 29),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectKernelModules",
                     position: (496, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (496, 32),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectKernelTunables",
                     position: (497, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (497, 33),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectProc",
                     position: (498, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "invisible",
                     position: (498, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProcSubset",
                     position: (499, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "all",
                     position: (499, 23),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ProtectSystem",
                     position: (500, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "strict",
                     position: (500, 26),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RemoveIPC",
                     position: (501, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (501, 21),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ReadWritePaths",
                     position: (502, 9),
                    },
                   ],
                  },
                  LetIn {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "cfgPath",
                        position: (504, 11),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "config",
                          position: (504, 24),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "homeassistant",
                          position: (504, 33),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "allowlist_external_dirs",
                          position: (504, 49),
                         },
                        ],
                       },
                      ],
                      position: (504, 21),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "value",
                        position: (505, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "attrByPath",
                       position: (505, 19),
                      },
                      arguments: [
                       Variable {
                        identifier: "cfgPath",
                        position: (505, 30),
                       },
                       List {
                        elements: [],
                        position: (505, 38),
                       },
                       Variable {
                        identifier: "cfg",
                        position: (505, 41),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "allowPaths",
                        position: (506, 11),
                       },
                      ],
                     },
                     IfThenElse {
                      predicate: FunctionApplication {
                       function: Variable {
                        identifier: "isList",
                        position: (506, 27),
                       },
                       arguments: [
                        Variable {
                         identifier: "value",
                         position: (506, 34),
                        },
                       ],
                      },
                      then: Variable {
                       identifier: "value",
                       position: (506, 45),
                      },
                      else_: FunctionApplication {
                       function: Variable {
                        identifier: "singleton",
                        position: (506, 56),
                       },
                       arguments: [
                        Variable {
                         identifier: "value",
                         position: (506, 66),
                        },
                       ],
                      },
                      position: (506, 24),
                     },
                    ),
                   ],
                   target: BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     List {
                      elements: [
                       String {
                        parts: [
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (507, 17),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "configDir",
                              position: (507, 21),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                        ],
                       },
                      ],
                      position: (507, 12),
                     },
                     Variable {
                      identifier: "allowPaths",
                      position: (507, 38),
                     },
                    ],
                    position: (507, 35),
                   },
                   position: (502, 26),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RestrictAddressFamilies",
                     position: (508, 9),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "AF_INET",
                         position: (509, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "AF_INET6",
                         position: (510, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "AF_NETLINK",
                         position: (511, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "AF_UNIX",
                         position: (512, 12),
                        },
                       ],
                      },
                     ],
                     position: (508, 35),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionals",
                      position: (513, 14),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "any",
                        position: (513, 25),
                       },
                       arguments: [
                        Variable {
                         identifier: "useComponent",
                         position: (513, 29),
                        },
                        Variable {
                         identifier: "componentsUsingBluetooth",
                         position: (513, 42),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "AF_BLUETOOTH",
                           position: (514, 12),
                          },
                         ],
                        },
                       ],
                       position: (513, 68),
                      },
                     ],
                    },
                   ],
                   position: (513, 11),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RestrictNamespaces",
                     position: (516, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (516, 30),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RestrictRealtime",
                     position: (517, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (517, 28),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "RestrictSUIDSGID",
                     position: (518, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (518, 28),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "SupplementaryGroups",
                     position: (519, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionals",
                    position: (519, 31),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "any",
                      position: (519, 42),
                     },
                     arguments: [
                      Variable {
                       identifier: "useComponent",
                       position: (519, 46),
                      },
                      Variable {
                       identifier: "componentsUsingSerialDevices",
                       position: (519, 59),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "dialout",
                         position: (520, 12),
                        },
                       ],
                      },
                     ],
                     position: (519, 89),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "SystemCallArchitectures",
                     position: (522, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "native",
                     position: (522, 36),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "SystemCallFilter",
                     position: (523, 9),
                    },
                   ],
                  },
                  BinaryOperation {
                   operator: Concatenation,
                   operands: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "@system-service",
                         position: (524, 12),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "~@privileged",
                         position: (525, 12),
                        },
                       ],
                      },
                     ],
                     position: (523, 28),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionals",
                      position: (526, 14),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "any",
                        position: (526, 25),
                       },
                       arguments: [
                        Variable {
                         identifier: "useComponent",
                         position: (526, 29),
                        },
                        Variable {
                         identifier: "componentsUsingPing",
                         position: (526, 42),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "capset",
                           position: (527, 12),
                          },
                         ],
                        },
                       ],
                       position: (526, 63),
                      },
                     ],
                    },
                   ],
                   position: (526, 11),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "UMask",
                     position: (529, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "0077",
                     position: (529, 18),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (467, 10),
               },
               position: (391, 23),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (531, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "/run/wrappers",
                   position: (532, 10),
                  },
                 ],
                },
               ],
               position: (531, 14),
              },
             ),
            ],
            recursive: false,
            position: (365, 39),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (536, 5),
             },
             Raw {
              content: "targets",
              position: (536, 13),
             },
             Raw {
              content: "home-assistant",
              position: (536, 21),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (537, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Home Assistant",
                 position: (537, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (538, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (538, 21),
                  },
                 ],
                },
               ],
               position: (538, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wants",
                 position: (539, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "home-assistant.service",
                   position: (539, 18),
                  },
                 ],
                },
               ],
               position: (539, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (540, 7),
                },
               ],
              },
              Variable {
               identifier: "wants",
               position: (540, 15),
              },
             ),
            ],
            recursive: true,
            position: (536, 38),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (543, 5),
             },
             Raw {
              content: "users",
              position: (543, 11),
             },
             Raw {
              content: "hass",
              position: (543, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (544, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (544, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "configDir",
                  position: (544, 18),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (545, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (545, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (546, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "hass",
                 position: (546, 16),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (547, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (547, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (547, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (547, 24),
                 },
                 Raw {
                  content: "hass",
                  position: (547, 29),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (543, 24),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (550, 5),
             },
             Raw {
              content: "groups",
              position: (550, 11),
             },
             Raw {
              content: "hass",
              position: (550, 18),
             },
             Raw {
              content: "gid",
              position: (550, 23),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (550, 29),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (550, 36),
              },
              Raw {
               content: "gids",
               position: (550, 40),
              },
              Raw {
               content: "hass",
               position: (550, 45),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         recursive: false,
         position: (362, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (64, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}