---
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: (5, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (9, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (9, 16),
        },
        Raw {
         content: "upower",
         position: (9, 25),
        },
       ],
      },
      default: None,
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (17, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (19, 5),
           },
           Raw {
            content: "upower",
            position: (19, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (21, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (21, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (22, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (22, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (22, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (23, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (23, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (24, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable Upower, a DBus service that provides power\nmanagement support to applications.\n",
                    position: (25, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (21, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (30, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (30, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (31, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (31, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (31, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (32, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (32, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "upower",
                     position: (32, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (33, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (33, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.upower",
                      position: (33, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (34, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Which upower package to use.\n",
                    position: (35, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (30, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableWattsUpPro",
               position: (39, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (39, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (40, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (40, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (40, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (41, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (41, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (42, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enable the Watts Up Pro device.\n\nThe Watts Up Pro contains a generic FTDI USB device without a specific\nvendor and product ID. When we probe for WUP devices, we can cause\nthe user to get a perplexing \"Device or resource busy\" error when\nattempting to use their non-WUP device.\n\nThe generic FTDI device is known to also be used on:\n\n<itemizedlist>\n  <listitem><para>Sparkfun FT232 breakout board</para></listitem>\n  <listitem><para>Parallax Propeller</para></listitem>\n</itemizedlist>\n",
                    position: (43, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (39, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "noPollBatteries",
               position: (59, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (59, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (60, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (60, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (60, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (61, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (61, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (62, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Don't poll the kernel for battery level changes.\n\nSome hardware will send us battery level changes through\nevents, rather than us having to poll for it. This option\nallows disabling polling for hardware that sends out events.\n",
                    position: (63, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (59, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "ignoreLid",
               position: (71, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (71, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (72, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (72, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (72, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (73, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (73, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (74, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Do we ignore the lid state\n\nSome laptops are broken. The lid state is either inverted, or stuck\non or off. We can't do much to fix these problems, but this is a way\nfor users to make the laptop panel vanish, a state that might be used\nby a couple of user-space daemons. On Linux systems, see also\nlogind.conf(5).\n",
                    position: (75, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (71, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "usePercentageForPolicy",
               position: (85, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (85, 32),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (86, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (86, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (86, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (87, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (87, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (88, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Policy for warnings and action based on battery levels\n\nWhether battery percentage based policy should be used. The default\nis to use the percentage, which\nshould work around broken firmwares. It is also more reliable than\nthe time left (frantically saving all your files is going to use more\nbattery than letting it rest for example).\n",
                    position: (89, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (85, 41),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "percentageLow",
               position: (99, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (99, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (100, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (100, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (100, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (100, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (101, 9),
                   },
                  ],
                 },
                 Int {
                  value: 10,
                  position: (101, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (102, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>true</literal>, the levels at which UPower will consider the\nbattery low.\n\nThis will also be used for batteries which don't have time information\nsuch as that of peripherals.\n\nIf any value (of <literal>percentageLow</literal>,\n<literal>percentageCritical</literal> and\n<literal>percentageAction</literal>) is invalid, or not in descending\norder, the defaults will be used.\n",
                    position: (103, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (99, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "percentageCritical",
               position: (117, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (117, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (118, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (118, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (118, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (118, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (119, 9),
                   },
                  ],
                 },
                 Int {
                  value: 3,
                  position: (119, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (120, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>true</literal>, the levels at which UPower will consider the\nbattery critical.\n\nThis will also be used for batteries which don't have time information\nsuch as that of peripherals.\n\nIf any value (of <literal>percentageLow</literal>,\n<literal>percentageCritical</literal> and\n<literal>percentageAction</literal>) is invalid, or not in descending\norder, the defaults will be used.\n",
                    position: (121, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (117, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "percentageAction",
               position: (135, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (135, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (136, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (136, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (136, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (136, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (137, 9),
                   },
                  ],
                 },
                 Int {
                  value: 2,
                  position: (137, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (138, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>true</literal>, the levels at which UPower will take action\nfor the critical battery level.\n\nThis will also be used for batteries which don't have time information\nsuch as that of peripherals.\n\nIf any value (of <literal>percentageLow</literal>,\n<literal>percentageCritical</literal> and\n<literal>percentageAction</literal>) is invalid, or not in descending\norder, the defaults will be used.\n",
                    position: (139, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (135, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "timeLow",
               position: (153, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (153, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (154, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (154, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (154, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (154, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (155, 9),
                   },
                  ],
                 },
                 Int {
                  value: 1200,
                  position: (155, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (156, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>false</literal>, the time remaining in seconds at which\nUPower will consider the battery low.\n\nIf any value (of <literal>timeLow</literal>,\n<literal>timeCritical</literal> and <literal>timeAction</literal>) is\ninvalid, or not in descending order, the defaults will be used.\n",
                    position: (157, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (153, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "timeCritical",
               position: (167, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (167, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (168, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (168, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (168, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (168, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (169, 9),
                   },
                  ],
                 },
                 Int {
                  value: 300,
                  position: (169, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (170, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>false</literal>, the time remaining in seconds at which\nUPower will consider the battery critical.\n\nIf any value (of <literal>timeLow</literal>,\n<literal>timeCritical</literal> and <literal>timeAction</literal>) is\ninvalid, or not in descending order, the defaults will be used.\n",
                    position: (171, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (167, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "timeAction",
               position: (181, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (181, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (182, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (182, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "ints",
                     position: (182, 22),
                    },
                    Raw {
                     content: "unsigned",
                     position: (182, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (183, 9),
                   },
                  ],
                 },
                 Int {
                  value: 120,
                  position: (183, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (184, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "When <literal>usePercentageForPolicy</literal> is\n<literal>false</literal>, the time remaining in seconds at which\nUPower will take action for the critical battery level.\n\nIf any value (of <literal>timeLow</literal>,\n<literal>timeCritical</literal> and <literal>timeAction</literal>) is\ninvalid, or not in descending order, the defaults will be used.\n",
                    position: (185, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (181, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "criticalPowerAction",
               position: (195, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (195, 29),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (196, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (196, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (196, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "PowerOff",
                        position: (196, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "Hibernate",
                        position: (196, 41),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "HybridSleep",
                        position: (196, 53),
                       },
                      ],
                     },
                    ],
                    position: (196, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (197, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "HybridSleep",
                    position: (197, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (198, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The action to take when <literal>timeAction</literal> or\n<literal>percentageAction</literal> has been reached for the batteries\n(UPS or laptop batteries) supplying the computer\n",
                    position: (199, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (195, 38),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (19, 23),
         },
        ),
       ],
       recursive: false,
       position: (17, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (212, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (212, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (212, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (212, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (214, 5),
             },
             Raw {
              content: "systemPackages",
              position: (214, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (214, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "package",
                 position: (214, 40),
                },
               ],
              },
              default: None,
             },
            ],
            position: (214, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (216, 5),
             },
             Raw {
              content: "dbus",
              position: (216, 14),
             },
             Raw {
              content: "packages",
              position: (216, 19),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (216, 32),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "package",
                 position: (216, 36),
                },
               ],
              },
              default: None,
             },
            ],
            position: (216, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (218, 5),
             },
             Raw {
              content: "udev",
              position: (218, 14),
             },
             Raw {
              content: "packages",
              position: (218, 19),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (218, 32),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "package",
                 position: (218, 36),
                },
               ],
              },
              default: None,
             },
            ],
            position: (218, 30),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (220, 5),
             },
             Raw {
              content: "packages",
              position: (220, 13),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (220, 26),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "package",
                 position: (220, 30),
                },
               ],
              },
              default: None,
             },
            ],
            position: (220, 24),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (222, 5),
             },
             Raw {
              content: "etc",
              position: (222, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "UPower/UPower.conf",
                 position: (222, 22),
                },
               ],
              },
             },
             Raw {
              content: "text",
              position: (222, 42),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "generators",
              position: (222, 49),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toINI",
                position: (222, 60),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [],
              recursive: false,
              position: (222, 66),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "UPower",
                   position: (223, 7),
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "EnableWattsUpPro",
                      position: (224, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (224, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enableWattsUpPro",
                       position: (224, 32),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "NoPollBatteries",
                      position: (225, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (225, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "noPollBatteries",
                       position: (225, 31),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "IgnoreLid",
                      position: (226, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (226, 21),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "ignoreLid",
                       position: (226, 25),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "UsePercentageForPolicy",
                      position: (227, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (227, 34),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "usePercentageForPolicy",
                       position: (227, 38),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PercentageLow",
                      position: (228, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (228, 25),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "percentageLow",
                       position: (228, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PercentageCritical",
                      position: (229, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (229, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "percentageCritical",
                       position: (229, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "PercentageAction",
                      position: (230, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (230, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "percentageAction",
                       position: (230, 32),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeLow",
                      position: (231, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (231, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "timeLow",
                       position: (231, 23),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeCritical",
                      position: (232, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (232, 24),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "timeCritical",
                       position: (232, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "TimeAction",
                      position: (233, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (233, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "timeAction",
                       position: (233, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "CriticalPowerAction",
                      position: (234, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (234, 31),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "criticalPowerAction",
                       position: (234, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                 ],
                 recursive: false,
                 position: (223, 16),
                },
               ),
              ],
              recursive: false,
              position: (222, 69),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (212, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (13, 1),
   },
   position: (7, 1),
  },
  position: (5, 1),
 },
 position: (3, 1),
}