---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cfg",
       position: (4, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (4, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "services",
        position: (4, 16),
       },
       Raw {
        content: "zoneminder",
        position: (4, 25),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "fpm",
       position: (5, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (5, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "services",
        position: (5, 16),
       },
       Raw {
        content: "phpfpm",
        position: (5, 25),
       },
       Raw {
        content: "pools",
        position: (5, 32),
       },
       Raw {
        content: "zoneminder",
        position: (5, 38),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "pkg",
       position: (6, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "pkgs",
      position: (6, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "zoneminder",
        position: (6, 14),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "dirName",
       position: (8, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "pkg",
      position: (8, 13),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "dirName",
        position: (8, 17),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "user",
       position: (10, 3),
      },
     ],
    },
    String {
     parts: [
      Raw {
       content: "zoneminder",
       position: (10, 11),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "group",
       position: (11, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "nginx",
           position: (12, 5),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "config",
          position: (12, 13),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (12, 20),
           },
           Raw {
            content: "nginx",
            position: (12, 29),
           },
           Raw {
            content: "group",
            position: (12, 35),
           },
          ],
         },
         default: None,
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "none",
           position: (13, 5),
          },
         ],
        },
        Variable {
         identifier: "user",
         position: (13, 13),
        },
       ),
      ],
      recursive: false,
      position: (11, 11),
     },
     attribute_path: AttributePath {
      attributes: [
       Expression {
        expression: PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (14, 7),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "webserver",
            position: (14, 11),
           },
          ],
         },
         default: None,
        },
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "useNginx",
       position: (16, 3),
      },
     ],
    },
    BinaryOperation {
     operator: EqualTo,
     operands: [
      PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (16, 14),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "webserver",
          position: (16, 18),
         },
        ],
       },
       default: None,
      },
      String {
       parts: [
        Raw {
         content: "nginx",
         position: (16, 32),
        },
       ],
      },
     ],
     position: (16, 28),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "defaultDir",
       position: (18, 3),
      },
     ],
    },
    String {
     parts: [
      Raw {
       content: "/var/lib/",
       position: (18, 17),
      },
      Expression {
       expression: Variable {
        identifier: "user",
        position: (18, 28),
       },
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "home",
       position: (19, 3),
      },
     ],
    },
    IfThenElse {
     predicate: Variable {
      identifier: "useCustomDir",
      position: (19, 13),
     },
     then: PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (19, 31),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "storageDir",
         position: (19, 35),
        },
       ],
      },
      default: None,
     },
     else_: Variable {
      identifier: "defaultDir",
      position: (19, 51),
     },
     position: (19, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "useCustomDir",
       position: (21, 3),
      },
     ],
    },
    BinaryOperation {
     operator: NotEqualTo,
     operands: [
      PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (21, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "storageDir",
          position: (21, 22),
         },
        ],
       },
       default: None,
      },
      Variable {
       identifier: "null",
       position: (21, 36),
      },
     ],
     position: (21, 33),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "zms",
       position: (23, 3),
      },
     ],
    },
    String {
     parts: [
      Raw {
       content: "/cgi-bin/zms",
       position: (23, 10),
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "dirs",
       position: (25, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "dirList",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: BinaryOperation {
      operator: Concatenation,
      operands: [
       List {
        elements: [
         Variable {
          identifier: "dirName",
          position: (25, 21),
         },
        ],
        position: (25, 19),
       },
       FunctionApplication {
        function: Variable {
         identifier: "map",
         position: (25, 34),
        },
        arguments: [
         Function {
          argument: Some(
           "e",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: String {
           parts: [
            Expression {
             expression: Variable {
              identifier: "dirName",
              position: (25, 45),
             },
            },
            Raw {
             content: "/",
             position: (25, 53),
            },
            Expression {
             expression: Variable {
              identifier: "e",
              position: (25, 56),
             },
            },
           ],
          },
          position: (25, 39),
         },
         Variable {
          identifier: "dirList",
          position: (25, 61),
         },
        ],
       },
      ],
      position: (25, 31),
     },
     position: (25, 10),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cacheDirs",
       position: (27, 3),
      },
     ],
    },
    List {
     elements: [
      String {
       parts: [
        Raw {
         content: "swap",
         position: (27, 18),
        },
       ],
      },
     ],
     position: (27, 15),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "libDirs",
       position: (28, 3),
      },
     ],
    },
    List {
     elements: [
      String {
       parts: [
        Raw {
         content: "events",
         position: (28, 18),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "exports",
         position: (28, 27),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "images",
         position: (28, 37),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "sounds",
         position: (28, 46),
        },
       ],
      },
     ],
     position: (28, 15),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "dirStanzas",
       position: (30, 3),
      },
     ],
    },
    Function {
     argument: Some(
      "baseDir",
     ),
     arguments: FunctionArguments {
      arguments: [],
      ellipsis: false,
     },
     definition: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (31, 5),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "concatStringsSep",
          position: (31, 9),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "\n",
          position: (31, 27),
         },
        ],
       },
       FunctionApplication {
        function: Variable {
         identifier: "map",
         position: (31, 32),
        },
        arguments: [
         Function {
          argument: Some(
           "e",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: String {
           parts: [
            Raw {
             content: "ZM_DIR_",
             position: (32, 8),
            },
            Expression {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (32, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "toUpper",
                  position: (32, 21),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "e",
                position: (32, 29),
               },
              ],
             },
            },
            Raw {
             content: "=",
             position: (32, 31),
            },
            Expression {
             expression: Variable {
              identifier: "baseDir",
              position: (32, 34),
             },
            },
            Raw {
             content: "/",
             position: (32, 42),
            },
            Expression {
             expression: Variable {
              identifier: "e",
              position: (32, 45),
             },
            },
           ],
          },
          position: (31, 37),
         },
         Variable {
          identifier: "libDirs",
          position: (33, 9),
         },
        ],
       },
      ],
     },
     position: (30, 16),
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "defaultsFile",
       position: (35, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (35, 18),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "writeText",
         position: (35, 23),
        },
       ],
      },
      default: None,
     },
     arguments: [
      String {
       parts: [
        Raw {
         content: "60-defaults.conf",
         position: (35, 34),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "# 01-system-paths.conf\n",
         position: (36, 1),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "dirStanzas",
           position: (37, 7),
          },
          arguments: [
           Variable {
            identifier: "home",
            position: (37, 18),
           },
          ],
         },
        },
        Raw {
         content: "\nZM_PATH_ARP=",
         position: (37, 23),
        },
        Expression {
         expression: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (38, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "getBin",
              position: (38, 23),
             },
            ],
           },
           default: None,
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "pkgs",
             position: (38, 30),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "nettools",
               position: (38, 35),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: "/bin/arp\nZM_PATH_LOGS=/var/log/",
         position: (38, 44),
        },
        Expression {
         expression: Variable {
          identifier: "dirName",
          position: (39, 29),
         },
        },
        Raw {
         content: "\nZM_PATH_MAP=/dev/shm\nZM_PATH_SOCKS=/run/",
         position: (39, 37),
        },
        Expression {
         expression: Variable {
          identifier: "dirName",
          position: (41, 26),
         },
        },
        Raw {
         content: "\nZM_PATH_SWAP=/var/cache/",
         position: (41, 34),
        },
        Expression {
         expression: Variable {
          identifier: "dirName",
          position: (42, 31),
         },
        },
        Raw {
         content: "/swap\nZM_PATH_ZMS=",
         position: (42, 39),
        },
        Expression {
         expression: Variable {
          identifier: "zms",
          position: (43, 19),
         },
        },
        Raw {
         content: "\n\n# 02-multiserver.conf\nZM_SERVER_HOST=\n\n# Database\nZM_DB_TYPE=mysql\nZM_DB_HOST=",
         position: (43, 23),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (50, 18),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (50, 22),
            },
            Raw {
             content: "host",
             position: (50, 31),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\nZM_DB_NAME=",
         position: (50, 36),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (51, 18),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (51, 22),
            },
            Raw {
             content: "name",
             position: (51, 31),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\nZM_DB_USER=",
         position: (51, 36),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (52, 18),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (52, 22),
            },
            Raw {
             content: "username",
             position: (52, 31),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\nZM_DB_PASS=",
         position: (52, 40),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (53, 18),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "database",
             position: (53, 22),
            },
            Raw {
             content: "password",
             position: (53, 31),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\n\n# Web\nZM_WEB_USER=",
         position: (53, 40),
        },
        Expression {
         expression: Variable {
          identifier: "user",
          position: (56, 19),
         },
        },
        Raw {
         content: "\nZM_WEB_GROUP=",
         position: (56, 24),
        },
        Expression {
         expression: Variable {
          identifier: "group",
          position: (57, 20),
         },
        },
        Raw {
         content: "\n",
         position: (57, 26),
        },
       ],
      },
     ],
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "configFile",
       position: (60, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (60, 16),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "writeText",
         position: (60, 21),
        },
       ],
      },
      default: None,
     },
     arguments: [
      String {
       parts: [
        Raw {
         content: "80-nixos.conf",
         position: (60, 32),
        },
       ],
      },
      String {
       parts: [
        Raw {
         content: "# You can override defaults here\n\n",
         position: (61, 1),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (63, 7),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "extraConfig",
             position: (63, 11),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\n",
         position: (63, 23),
        },
       ],
      },
     ],
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (67, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "services",
           position: (68, 5),
          },
          Raw {
           content: "zoneminder",
           position: (68, 14),
          },
         ],
        },
        With {
         expression: Variable {
          identifier: "lib",
          position: (68, 32),
         },
         target: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (69, 7),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (69, 16),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "mkEnableOption",
                 position: (69, 20),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "ZoneMinder\n</para><para>\nIf you intend to run the database locally, you should set\n`config.services.zoneminder.database.createLocally` to true. Otherwise,\nwhen set to `false` (the default), you will have to create the database\nand database user as well as populate the database yourself.\nAdditionally, you will need to run `zmupdate.pl` yourself when\nupgrading to a newer version.\n",
                 position: (70, 1),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "webserver",
               position: (80, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (80, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (81, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (81, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (81, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "nginx",
                        position: (81, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "none",
                        position: (81, 38),
                       },
                      ],
                     },
                    ],
                    position: (81, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (82, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "nginx",
                    position: (82, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (83, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The webserver to configure for the PHP frontend.\n</para>\n<para>\n\nSet it to `none` if you want to configure it yourself. PRs are welcome\nfor support for other web servers.\n",
                    position: (84, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (80, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "hostname",
               position: (93, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (93, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (94, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (94, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (94, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (95, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost",
                    position: (95, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (96, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The hostname on which to listen.\n",
                    position: (97, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (93, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (101, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (101, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (102, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (102, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (102, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (103, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8095,
                  position: (103, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (104, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The port on which to listen.\n",
                    position: (105, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (101, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "openFirewall",
               position: (109, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (109, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (110, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (110, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (110, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (111, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (111, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (112, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Open the firewall port(s).\n",
                    position: (113, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (109, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "database",
               position: (117, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "createLocally",
                  position: (118, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (118, 25),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (119, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (119, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (119, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (120, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (120, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (121, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Create the database and database user locally.\n",
                       position: (122, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (118, 34),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "host",
                  position: (126, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (126, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (127, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (127, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (127, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (128, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "localhost",
                       position: (128, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (129, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Hostname hosting the database.\n",
                       position: (130, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (126, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (134, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (134, 16),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (135, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (135, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (135, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (136, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "zm",
                       position: (136, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (137, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Name of database.\n",
                       position: (138, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (134, 25),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "username",
                  position: (142, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (142, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (143, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (143, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (143, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (144, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "zmuser",
                       position: (144, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (145, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Username for accessing the database.\n",
                       position: (146, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (142, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "password",
                  position: (150, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (150, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (151, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (151, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (151, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (152, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "zmpass",
                       position: (152, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (153, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Username for accessing the database.\nNot used if <literal>createLocally</literal> is set.\n",
                       position: (154, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (150, 29),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (117, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cameras",
               position: (160, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (160, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (161, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (161, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (161, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (162, 9),
                   },
                  ],
                 },
                 Int {
                  value: 1,
                  position: (162, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (163, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set this to the number of cameras you expect to support.\n",
                    position: (164, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (160, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "storageDir",
               position: (168, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (168, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (169, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (169, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (169, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (169, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (169, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (170, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (170, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (171, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/storage/tank",
                    position: (171, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (172, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ZoneMinder can generate quite a lot of data, so in case you don't want\nto use the default ",
                    position: (173, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "defaultDir",
                     position: (174, 32),
                    },
                   },
                   Raw {
                    content: ", you can override the path here.\n",
                    position: (174, 43),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (168, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (178, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (178, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (179, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (179, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (179, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (180, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (181, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Additional configuration added verbatim to the configuration file.\n",
                    position: (182, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (178, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (68, 37),
         },
         position: (68, 27),
        },
       ),
      ],
      recursive: false,
      position: (67, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (188, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (188, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "mkIf",
          position: (188, 16),
         },
        ],
       },
       default: None,
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (188, 21),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (188, 25),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "assertions",
             position: (190, 5),
            },
           ],
          },
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "assertion",
                  position: (191, 9),
                 },
                ],
               },
               BinaryOperation {
                operator: Implication,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (191, 21),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "database",
                     position: (191, 25),
                    },
                    Raw {
                     content: "createLocally",
                     position: (191, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (191, 51),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "database",
                       position: (191, 55),
                      },
                      Raw {
                       content: "username",
                       position: (191, 64),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "user",
                    position: (191, 76),
                   },
                  ],
                  position: (191, 73),
                 },
                ],
                position: (191, 48),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "message",
                  position: (192, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "services.zoneminder.database.username must be set to ",
                  position: (192, 20),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "user",
                   position: (192, 75),
                  },
                 },
                 Raw {
                  content: " if services.zoneminder.database.createLocally is set true",
                  position: (192, 80),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (191, 7),
            },
           ],
           position: (190, 18),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "environment",
             position: (196, 5),
            },
            Raw {
             content: "etc",
             position: (196, 17),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: String {
                 parts: [
                  Raw {
                   content: "zoneminder/60-defaults.conf",
                   position: (197, 8),
                  },
                 ],
                },
               },
               Raw {
                content: "source",
                position: (197, 37),
               },
              ],
             },
             Variable {
              identifier: "defaultsFile",
              position: (197, 46),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Expression {
                expression: String {
                 parts: [
                  Raw {
                   content: "zoneminder/80-nixos.conf",
                   position: (198, 8),
                  },
                 ],
                },
               },
               Raw {
                content: "source",
                position: (198, 34),
               },
              ],
             },
             Variable {
              identifier: "configFile",
              position: (198, 46),
             },
            ),
           ],
           recursive: false,
           position: (196, 23),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "networking",
             position: (201, 5),
            },
            Raw {
             content: "firewall",
             position: (201, 16),
            },
            Raw {
             content: "allowedTCPPorts",
             position: (201, 25),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (201, 43),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "mkIf",
               position: (201, 47),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (201, 52),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "openFirewall",
                position: (201, 56),
               },
              ],
             },
             default: None,
            },
            List {
             elements: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (202, 7),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "port",
                  position: (202, 11),
                 },
                ],
               },
               default: None,
              },
              Int {
               value: 6802,
               position: (203, 7),
              },
             ],
             position: (201, 69),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (206, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "fcgiwrap",
                position: (207, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (207, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mkIf",
                  position: (207, 22),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "useNginx",
                position: (207, 27),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "enable",
                     position: (208, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (208, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preforkProcesses",
                     position: (209, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (209, 28),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "cameras",
                      position: (209, 32),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 Inherit(
                  None,
                  [
                   Raw {
                    content: "user",
                    position: (210, 17),
                   },
                   Raw {
                    content: "group",
                    position: (210, 22),
                   },
                  ],
                 ),
                ],
                recursive: false,
                position: (207, 36),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "mysql",
                position: (213, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (213, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mkIf",
                  position: (213, 19),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (213, 24),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "database",
                   position: (213, 28),
                  },
                  Raw {
                   content: "createLocally",
                   position: (213, 37),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "enable",
                     position: (214, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (214, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (215, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (215, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "mkDefault",
                       position: (215, 23),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (215, 33),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "mariadb",
                        position: (215, 38),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ensureDatabases",
                     position: (216, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (216, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (216, 33),
                       },
                       Raw {
                        content: "name",
                        position: (216, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (216, 27),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "ensureUsers",
                     position: (217, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "name",
                          position: (218, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (218, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "database",
                           position: (218, 22),
                          },
                          Raw {
                           content: "username",
                           position: (218, 31),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "ensurePermissions",
                          position: (219, 11),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (219, 36),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "database",
                                    position: (219, 40),
                                   },
                                   Raw {
                                    content: "name",
                                    position: (219, 49),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: ".*",
                                position: (219, 54),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "ALL PRIVILEGES",
                             position: (219, 61),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (219, 31),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (217, 24),
                    },
                   ],
                   position: (217, 23),
                  },
                 ),
                ],
                recursive: false,
                position: (213, 51),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "nginx",
                position: (223, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (223, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mkIf",
                  position: (223, 19),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "useNginx",
                position: (223, 24),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "enable",
                     position: (224, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (224, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "virtualHosts",
                     position: (225, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (226, 13),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "hostname",
                            position: (226, 17),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "default",
                           position: (227, 13),
                          },
                         ],
                        },
                        Variable {
                         identifier: "true",
                         position: (227, 23),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "root",
                           position: (228, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "pkg",
                            position: (228, 23),
                           },
                          },
                          Raw {
                           content: "/share/zoneminder/www",
                           position: (228, 27),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "listen",
                           position: (229, 13),
                          },
                         ],
                        },
                        List {
                         elements: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "addr",
                                position: (229, 26),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "0.0.0.0",
                                position: (229, 34),
                               },
                              ],
                             },
                            ),
                            Inherit(
                             Some(
                              Variable {
                               identifier: "cfg",
                               position: (229, 53),
                              },
                             ),
                             [
                              Raw {
                               content: "port",
                               position: (229, 58),
                              },
                             ],
                            ),
                           ],
                           recursive: false,
                           position: (229, 24),
                          },
                         ],
                         position: (229, 22),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "extraConfig",
                           position: (230, 13),
                          },
                         ],
                        },
                        LetIn {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "fcgi",
                              position: (231, 15),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "config",
                             position: (231, 22),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "services",
                               position: (231, 29),
                              },
                              Raw {
                               content: "fcgiwrap",
                               position: (231, 38),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                         ],
                         target: String {
                          parts: [
                           Raw {
                            content: "index index.php;\n\nlocation / {\n  try_files $uri $uri/ /index.php?$args =404;\n\n  rewrite ^/skins/.*/css/fonts/(.*)$ /fonts/$1 permanent;\n\n  location ~ /api/(css|img|ico) {\n    rewrite ^/api(.+)$ /api/app/webroot/$1 break;\n    try_files $uri $uri/ =404;\n  }\n\n  location ~ \\.(gif|ico|jpg|jpeg|png)$ {\n    access_log off;\n    expires 30d;\n  }\n\n  location /api {\n    rewrite ^/api(.+)$ /api/app/webroot/index.php?p=$1 last;\n  }\n\n  location /cgi-bin {\n    gzip off;\n\n    include ",
                            position: (233, 1),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "config",
                              position: (257, 29),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "services",
                                position: (257, 36),
                               },
                               Raw {
                                content: "nginx",
                                position: (257, 45),
                               },
                               Raw {
                                content: "package",
                                position: (257, 51),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "/conf/fastcgi_params;\n    fastcgi_param SCRIPT_FILENAME ",
                            position: (257, 59),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "pkg",
                             position: (258, 51),
                            },
                           },
                           Raw {
                            content: "/libexec/zoneminder/",
                            position: (258, 55),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "zms",
                             position: (258, 77),
                            },
                           },
                           Raw {
                            content: ";\n    fastcgi_param HTTP_PROXY \"\";\n    fastcgi_intercept_errors on;\n\n    fastcgi_pass ",
                            position: (258, 81),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "fcgi",
                              position: (262, 34),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "socketType",
                                position: (262, 39),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: ":",
                            position: (262, 50),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "fcgi",
                              position: (262, 53),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "socketAddress",
                                position: (262, 58),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: ";\n  }\n\n  location /cache/ {\n    alias /var/cache/",
                            position: (262, 72),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "dirName",
                             position: (266, 38),
                            },
                           },
                           Raw {
                            content: "/;\n  }\n\n  location ~ \\.php$ {\n    try_files $uri =404;\n    fastcgi_index index.php;\n\n    include ",
                            position: (266, 46),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "config",
                              position: (273, 29),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "services",
                                position: (273, 36),
                               },
                               Raw {
                                content: "nginx",
                                position: (273, 45),
                               },
                               Raw {
                                content: "package",
                                position: (273, 51),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: "/conf/fastcgi_params;\n    fastcgi_param SCRIPT_FILENAME $request_filename;\n    fastcgi_param HTTP_PROXY \"\";\n\n    fastcgi_pass unix:",
                            position: (273, 59),
                           },
                           Expression {
                            expression: PropertyAccess {
                             expression: Variable {
                              identifier: "fpm",
                              position: (277, 39),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "socket",
                                position: (277, 43),
                               },
                              ],
                             },
                             default: None,
                            },
                           },
                           Raw {
                            content: ";\n  }\n}\n",
                            position: (277, 50),
                           },
                          ],
                         },
                         position: (230, 27),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (226, 29),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (225, 24),
                  },
                 ),
                ],
                recursive: false,
                position: (223, 33),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "phpfpm",
                position: (285, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (285, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mkIf",
                  position: (285, 20),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "useNginx",
                position: (285, 25),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "pools",
                     position: (286, 9),
                    },
                    Raw {
                     content: "zoneminder",
                     position: (286, 15),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    Inherit(
                     None,
                     [
                      Raw {
                       content: "user",
                       position: (287, 19),
                      },
                      Raw {
                       content: "group",
                       position: (287, 24),
                      },
                     ],
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "phpPackage",
                        position: (288, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (288, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "php",
                          position: (288, 29),
                         },
                         Raw {
                          content: "withExtensions",
                          position: (288, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Function {
                        argument: None,
                        arguments: FunctionArguments {
                         arguments: [
                          FunctionArgument {
                           identifier: "all",
                           default: None,
                          },
                          FunctionArgument {
                           identifier: "enabled",
                           default: None,
                          },
                         ],
                         ellipsis: false,
                        },
                        definition: BinaryOperation {
                         operator: Concatenation,
                         operands: [
                          Variable {
                           identifier: "enabled",
                           position: (288, 67),
                          },
                          List {
                           elements: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "all",
                              position: (288, 80),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "apcu",
                                position: (288, 84),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                           position: (288, 78),
                          },
                         ],
                         position: (288, 75),
                        },
                        position: (288, 49),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "phpOptions",
                        position: (289, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "date.timezone = \"",
                        position: (290, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (290, 32),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "time",
                            position: (290, 39),
                           },
                           Raw {
                            content: "timeZone",
                            position: (290, 44),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "\"\n",
                        position: (290, 53),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "settings",
                        position: (292, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "lib",
                        position: (292, 22),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "mapAttrs",
                          position: (292, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "name",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: PropertyAccess {
                         expression: Variable {
                          identifier: "lib",
                          position: (292, 42),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "mkDefault",
                            position: (292, 46),
                           },
                          ],
                         },
                         default: None,
                        },
                        position: (292, 36),
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "listen.owner",
                                position: (293, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Variable {
                           identifier: "user",
                           position: (293, 30),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "listen.group",
                                position: (294, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Variable {
                           identifier: "group",
                           position: (294, 30),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "listen.mode",
                                position: (295, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "0660",
                             position: (295, 30),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm",
                                position: (297, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "dynamic",
                             position: (297, 21),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.start_servers",
                                position: (298, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Int {
                           value: 1,
                           position: (298, 34),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.min_spare_servers",
                                position: (299, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Int {
                           value: 1,
                           position: (299, 38),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.max_spare_servers",
                                position: (300, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Int {
                           value: 2,
                           position: (300, 38),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.max_requests",
                                position: (301, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Int {
                           value: 500,
                           position: (301, 33),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.max_children",
                                position: (302, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Int {
                           value: 5,
                           position: (302, 33),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "pm.status_path",
                                position: (303, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "/$pool-status",
                             position: (303, 33),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "ping.path",
                                position: (304, 14),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "/$pool-ping",
                             position: (304, 28),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (292, 57),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (286, 28),
                  },
                 ),
                ],
                recursive: false,
                position: (285, 34),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (206, 16),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "systemd",
             position: (310, 5),
            },
            Raw {
             content: "services",
             position: (310, 13),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "zoneminder",
                position: (311, 7),
               },
              ],
             },
             With {
              expression: Variable {
               identifier: "pkgs",
               position: (311, 25),
              },
              target: Map {
               bindings: [
                Inherit(
                 Some(
                  PropertyAccess {
                   expression: Variable {
                    identifier: "zoneminder",
                    position: (312, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "meta",
                      position: (312, 29),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 [
                  Raw {
                   content: "description",
                   position: (312, 35),
                  },
                 ],
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "documentation",
                    position: (313, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "https://zoneminder.readthedocs.org/en/latest/",
                      position: (313, 28),
                     },
                    ],
                   },
                  ],
                  position: (313, 25),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "path",
                    position: (314, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "coreutils",
                    position: (315, 11),
                   },
                   Variable {
                    identifier: "procps",
                    position: (316, 11),
                   },
                   Variable {
                    identifier: "psmisc",
                    position: (317, 11),
                   },
                  ],
                  position: (314, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "after",
                    position: (319, 9),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "nginx.service",
                        position: (319, 20),
                       },
                      ],
                     },
                    ],
                    position: (319, 17),
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (319, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "optional",
                        position: (319, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (319, 53),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (319, 57),
                        },
                        Raw {
                         content: "createLocally",
                         position: (319, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "mysql.service",
                        position: (319, 81),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                  position: (319, 37),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wantedBy",
                    position: (320, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "multi-user.target",
                      position: (320, 23),
                     },
                    ],
                   },
                  ],
                  position: (320, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "restartTriggers",
                    position: (321, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Variable {
                    identifier: "defaultsFile",
                    position: (321, 29),
                   },
                   Variable {
                    identifier: "configFile",
                    position: (321, 42),
                   },
                  ],
                  position: (321, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "preStart",
                    position: (322, 9),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (322, 20),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "optionalString",
                        position: (322, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Variable {
                      identifier: "useCustomDir",
                      position: (322, 39),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "install -dm775 -o ",
                        position: (323, 1),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "user",
                         position: (323, 31),
                        },
                       },
                       Raw {
                        content: " -g ",
                        position: (323, 36),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "group",
                         position: (323, 42),
                        },
                       },
                       Raw {
                        content: " ",
                        position: (323, 48),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (323, 51),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "storageDir",
                            position: (323, 55),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/{",
                        position: (323, 66),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "lib",
                           position: (323, 70),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "concatStringsSep",
                             position: (323, 74),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: ",",
                             position: (323, 92),
                            },
                           ],
                          },
                          Variable {
                           identifier: "libDirs",
                           position: (323, 95),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "}\n",
                        position: (323, 103),
                       },
                      ],
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "lib",
                      position: (324, 14),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "optionalString",
                        position: (324, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (324, 33),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (324, 37),
                        },
                        Raw {
                         content: "createLocally",
                         position: (324, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                     String {
                      parts: [
                       Raw {
                        content: "if ! test -e \"/var/lib/",
                        position: (325, 1),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dirName",
                         position: (325, 36),
                        },
                       },
                       Raw {
                        content: "/db-created\"; then\n  ",
                        position: (325, 44),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (326, 15),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "services",
                            position: (326, 22),
                           },
                           Raw {
                            content: "mysql",
                            position: (326, 31),
                           },
                           Raw {
                            content: "package",
                            position: (326, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/mysql < ",
                        position: (326, 45),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "pkg",
                         position: (326, 60),
                        },
                       },
                       Raw {
                        content: "/share/zoneminder/db/zm_create.sql\n  touch \"/var/lib/",
                        position: (326, 64),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "dirName",
                         position: (327, 31),
                        },
                       },
                       Raw {
                        content: "/db-created\"\nfi\n\n",
                        position: (327, 39),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "zoneminder",
                         position: (330, 13),
                        },
                       },
                       Raw {
                        content: "/bin/zmupdate.pl -nointeractive\n",
                        position: (330, 24),
                       },
                      ],
                     },
                    ],
                   },
                  ],
                  position: (324, 12),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (332, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "User",
                       position: (333, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "user",
                     position: (333, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Group",
                       position: (334, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "group",
                     position: (334, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "SupplementaryGroups",
                       position: (335, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "video",
                         position: (335, 36),
                        },
                       ],
                      },
                     ],
                     position: (335, 33),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (336, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "zoneminder",
                        position: (336, 27),
                       },
                      },
                      Raw {
                       content: "/bin/zmpkg.pl start",
                       position: (336, 38),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStop",
                       position: (337, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "zoneminder",
                        position: (337, 27),
                       },
                      },
                      Raw {
                       content: "/bin/zmpkg.pl stop",
                       position: (337, 38),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecReload",
                       position: (338, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "zoneminder",
                        position: (338, 27),
                       },
                      },
                      Raw {
                       content: "/bin/zmpkg.pl restart",
                       position: (338, 38),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PIDFile",
                       position: (339, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/run/",
                       position: (339, 22),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "dirName",
                        position: (339, 29),
                       },
                      },
                      Raw {
                       content: "/zm.pid",
                       position: (339, 37),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Type",
                       position: (340, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "forking",
                       position: (340, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Restart",
                       position: (341, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "on-failure",
                       position: (341, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RestartSec",
                       position: (342, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "10s",
                       position: (342, 25),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "CacheDirectory",
                       position: (343, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "dirs",
                      position: (343, 28),
                     },
                     arguments: [
                      Variable {
                       identifier: "cacheDirs",
                       position: (343, 33),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "RuntimeDirectory",
                       position: (344, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "dirName",
                     position: (344, 30),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ReadWriteDirectories",
                       position: (345, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "lib",
                       position: (345, 34),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "mkIf",
                         position: (345, 38),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "useCustomDir",
                       position: (345, 43),
                      },
                      List {
                       elements: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (345, 58),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "storageDir",
                            position: (345, 62),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (345, 56),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "StateDirectory",
                       position: (346, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "dirs",
                      position: (346, 28),
                     },
                     arguments: [
                      IfThenElse {
                       predicate: Variable {
                        identifier: "useCustomDir",
                        position: (346, 37),
                       },
                       then: List {
                        elements: [],
                        position: (346, 55),
                       },
                       else_: Variable {
                        identifier: "libDirs",
                        position: (346, 63),
                       },
                       position: (346, 34),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "LogsDirectory",
                       position: (347, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "dirName",
                     position: (347, 27),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "PrivateTmp",
                       position: (348, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (348, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ProtectSystem",
                       position: (349, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "strict",
                       position: (349, 28),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ProtectKernelTunables",
                       position: (350, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (350, 35),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "SystemCallArchitectures",
                       position: (351, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "native",
                       position: (351, 38),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "NoNewPrivileges",
                       position: (352, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (352, 29),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (332, 25),
                 },
                ),
               ],
               recursive: false,
               position: (311, 31),
              },
              position: (311, 20),
             },
            ),
           ],
           recursive: false,
           position: (310, 24),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "users",
             position: (357, 5),
            },
            Raw {
             content: "groups",
             position: (357, 11),
            },
            Expression {
             expression: Variable {
              identifier: "user",
              position: (357, 20),
             },
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "gid",
                position: (358, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (358, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "ids",
                 position: (358, 20),
                },
                Raw {
                 content: "gids",
                 position: (358, 24),
                },
                Raw {
                 content: "zoneminder",
                 position: (358, 29),
                },
               ],
              },
              default: None,
             },
            ),
           ],
           recursive: false,
           position: (357, 28),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "users",
             position: (361, 5),
            },
            Raw {
             content: "users",
             position: (361, 11),
            },
            Expression {
             expression: Variable {
              identifier: "user",
              position: (361, 19),
             },
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "uid",
                position: (362, 7),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "config",
               position: (362, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "ids",
                 position: (362, 20),
                },
                Raw {
                 content: "uids",
                 position: (362, 24),
                },
                Raw {
                 content: "zoneminder",
                 position: (362, 29),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "group",
                position: (363, 7),
               },
              ],
             },
             Variable {
              identifier: "user",
              position: (363, 15),
             },
            ),
            Inherit(
             None,
             [
              Raw {
               content: "home",
               position: (364, 15),
              },
             ],
            ),
            Inherit(
             Some(
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (365, 16),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "zoneminder",
                  position: (365, 21),
                 },
                 Raw {
                  content: "meta",
                  position: (365, 32),
                 },
                ],
               },
               default: None,
              },
             ),
             [
              Raw {
               content: "description",
               position: (365, 38),
              },
             ],
            ),
           ],
           recursive: false,
           position: (361, 27),
          },
         ),
        ],
        recursive: false,
        position: (188, 32),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "meta",
        position: (369, 3),
       },
       Raw {
        content: "maintainers",
        position: (369, 8),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (369, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "maintainers",
          position: (369, 31),
         },
        ],
       },
       default: None,
      },
      target: List {
       elements: [],
       position: (369, 44),
      },
      position: (369, 22),
     },
    ),
   ],
   recursive: false,
   position: (66, 4),
  },
  position: (3, 1),
 },
 position: (1, 1),
}