---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gid",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "ids",
         position: (7, 16),
        },
        Raw {
         content: "gids",
         position: (7, 20),
        },
        Raw {
         content: "mediatomb",
         position: (7, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (8, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (8, 16),
        },
        Raw {
         content: "mediatomb",
         position: (8, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (9, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (9, 17),
        },
        Raw {
         content: "mediatomb",
         position: (9, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "name",
        position: (10, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (10, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (10, 14),
        },
        Raw {
         content: "pname",
         position: (10, 22),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pkg",
        position: (11, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (11, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (11, 13),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "optionYesNo",
        position: (12, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "option",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: Variable {
        identifier: "option",
        position: (12, 28),
       },
       then: String {
        parts: [
         Raw {
          content: "yes",
          position: (12, 41),
         },
        ],
       },
       else_: String {
        parts: [
         Raw {
          content: "no",
          position: (12, 52),
         },
        ],
       },
       position: (12, 25),
      },
      position: (12, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mediaDirectory",
        position: (14, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "options",
           position: (15, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "path",
              position: (16, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (16, 14),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (17, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (17, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (17, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (18, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Absolute directory path to the media directory to index.\n",
                   position: (19, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (16, 23),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "recursive",
              position: (22, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (22, 19),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (23, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (23, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bool",
                    position: (23, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (24, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "false",
                 position: (24, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (25, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether the indexation must take place recursively or not.",
                   position: (25, 24),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (22, 28),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "hidden-files",
              position: (27, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (27, 22),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (28, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (28, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "bool",
                    position: (28, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (29, 9),
                  },
                 ],
                },
                Variable {
                 identifier: "true",
                 position: (29, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (30, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Whether to index the hidden files or not.",
                   position: (30, 24),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (27, 31),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (15, 15),
        },
       ),
      ],
      recursive: false,
      position: (14, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toMediaDirectory",
        position: (34, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "d",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: String {
       parts: [
        Raw {
         content: "<directory location=\"",
         position: (34, 26),
        },
        Expression {
         expression: PropertyAccess {
          expression: Variable {
           identifier: "d",
           position: (34, 50),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "path",
             position: (34, 52),
            },
           ],
          },
          default: None,
         },
        },
        Raw {
         content: "\" mode=\"inotify\" recursive=\"",
         position: (34, 57),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "optionYesNo",
           position: (34, 91),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "d",
             position: (34, 103),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "recursive",
               position: (34, 105),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: "\" hidden-files=\"",
         position: (34, 115),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "optionYesNo",
           position: (34, 135),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "d",
             position: (34, 147),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "hidden-files",
               position: (34, 149),
              },
             ],
            },
            default: None,
           },
          ],
         },
        },
        Raw {
         content: "\" />\n",
         position: (34, 162),
        },
       ],
      },
      position: (34, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "transcodingConfig",
        position: (36, 3),
       },
      ],
     },
     IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "cfg",
        position: (36, 26),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "transcoding",
          position: (36, 30),
         },
        ],
       },
       default: None,
      },
      then: With {
       expression: Variable {
        identifier: "pkgs",
        position: (36, 52),
       },
       target: String {
        parts: [
         Raw {
          content: "<transcoding enabled=\"yes\">\n  <mimetype-profile-mappings>\n    <transcode mimetype=\"video/x-flv\" using=\"vlcmpeg\" />\n    <transcode mimetype=\"application/ogg\" using=\"vlcmpeg\" />\n    <transcode mimetype=\"audio/ogg\" using=\"ogg2mp3\" />\n    <transcode mimetype=\"audio/x-flac\" using=\"oggflac2raw\"/>\n  </mimetype-profile-mappings>\n  <profiles>\n    <profile name=\"ogg2mp3\" enabled=\"no\" type=\"external\">\n      <mimetype>audio/mpeg</mimetype>\n      <accept-url>no</accept-url>\n      <first-resource>yes</first-resource>\n      <accept-ogg-theora>no</accept-ogg-theora>\n      <agent command=\"",
          position: (37, 1),
         },
         Expression {
          expression: Variable {
           identifier: "ffmpeg",
           position: (50, 29),
          },
         },
         Raw {
          content: "/bin/ffmpeg\" arguments=\"-y -i %in -f mp3 %out\" />\n      <buffer size=\"1048576\" chunk-size=\"131072\" fill-size=\"262144\" />\n    </profile>\n    <profile name=\"vlcmpeg\" enabled=\"no\" type=\"external\">\n      <mimetype>video/mpeg</mimetype>\n      <accept-url>yes</accept-url>\n      <first-resource>yes</first-resource>\n      <accept-ogg-theora>yes</accept-ogg-theora>\n      <agent command=\"",
          position: (50, 36),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "libsForQt5",
            position: (58, 29),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "vlc",
              position: (58, 40),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "/bin/vlc\"\n        arguments=\"-I dummy %in --sout #transcode{venc=ffmpeg,vcodec=mp2v,vb=4096,fps=25,aenc=ffmpeg,acodec=mpga,ab=192,samplerate=44100,channels=2}:standard{access=file,mux=ps,dst=%out} vlc:quit\" />\n      <buffer size=\"14400000\" chunk-size=\"512000\" fill-size=\"120000\" />\n    </profile>\n  </profiles>\n</transcoding>\n",
          position: (58, 44),
         },
        ],
       },
       position: (36, 47),
      },
      else_: String {
       parts: [
        Raw {
         content: "<transcoding enabled=\"no\">\n</transcoding>\n",
         position: (65, 1),
        },
       ],
      },
      position: (36, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configText",
        position: (69, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "optionalString",
       position: (69, 16),
      },
      arguments: [
       UnaryOperation {
        operator: Not,
        operand: PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (69, 34),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "customCfg",
            position: (69, 38),
           },
          ],
         },
         default: None,
        },
        position: (69, 32),
       },
       String {
        parts: [
         Raw {
          content: "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<config version=\"2\" xmlns=\"http://mediatomb.cc/config/2\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://mediatomb.cc/config/2 http://mediatomb.cc/config/2.xsd\">\n    <server>\n      <ui enabled=\"yes\" show-tooltips=\"yes\">\n        <accounts enabled=\"no\" session-timeout=\"30\">\n          <account user=\"",
          position: (70, 1),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (75, 28),
          },
         },
         Raw {
          content: "\" password=\"",
          position: (75, 33),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (75, 47),
          },
         },
         Raw {
          content: "\"/>\n        </accounts>\n      </ui>\n      <name>",
          position: (75, 52),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (78, 15),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "serverName",
              position: (78, 19),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "</name>\n      <udn>uuid:",
          position: (78, 30),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (79, 19),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "uuid",
              position: (79, 23),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "</udn>\n      <home>",
          position: (79, 28),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (80, 15),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dataDir",
              position: (80, 19),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "</home>\n      <interface>",
          position: (80, 27),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (81, 20),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "interface",
              position: (81, 24),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "</interface>\n      <webroot>",
          position: (81, 34),
         },
         Expression {
          expression: Variable {
           identifier: "pkg",
           position: (82, 18),
          },
         },
         Raw {
          content: "/share/",
          position: (82, 22),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (82, 31),
          },
         },
         Raw {
          content: "/web</webroot>\n      <pc-directory upnp-hide=\"",
          position: (82, 36),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionYesNo",
            position: (83, 34),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (83, 46),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "pcDirectoryHide",
                position: (83, 50),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\"/>\n      <storage>\n        <sqlite3 enabled=\"yes\">\n          <database-file>",
          position: (83, 66),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (86, 28),
          },
         },
         Raw {
          content: ".db</database-file>\n        </sqlite3>\n      </storage>\n      <protocolInfo extend=\"",
          position: (86, 33),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionYesNo",
            position: (89, 31),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (89, 43),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "ps3Support",
                position: (89, 47),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\"/>\n      ",
          position: (89, 58),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (90, 9),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (90, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "dsmSupport",
                position: (90, 28),
               },
              ],
             },
             default: None,
            },
            String {
             parts: [
              Raw {
               content: "<custom-http-headers>\n  <add header=\"X-User-Agent: redsonic\"/>\n</custom-http-headers>\n\n<manufacturerURL>redsonic.com</manufacturerURL>\n<modelNumber>105</modelNumber>\n",
               position: (91, 1),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n        ",
          position: (97, 10),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (98, 11),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (98, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "tg100Support",
                position: (98, 30),
               },
              ],
             },
             default: None,
            },
            String {
             parts: [
              Raw {
               content: "<upnp-string-limit>101</upnp-string-limit>\n",
               position: (99, 1),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n      <extended-runtime-options>\n        <mark-played-items enabled=\"yes\" suppress-cds-updates=\"yes\">\n          <string mode=\"prepend\">*</string>\n          <mark>\n            <content>video</content>\n          </mark>\n        </mark-played-items>\n      </extended-runtime-options>\n    </server>\n    <import hidden-files=\"no\">\n      <autoscan use-inotify=\"auto\">\n      ",
          position: (100, 10),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMapStrings",
            position: (112, 9),
           },
           arguments: [
            Variable {
             identifier: "toMediaDirectory",
             position: (112, 26),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (112, 43),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "mediaDirectories",
                position: (112, 47),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n      </autoscan>\n      <scripting script-charset=\"UTF-8\">\n        <common-script>",
          position: (112, 64),
         },
         Expression {
          expression: Variable {
           identifier: "pkg",
           position: (115, 26),
          },
         },
         Raw {
          content: "/share/",
          position: (115, 30),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (115, 39),
          },
         },
         Raw {
          content: "/js/common.js</common-script>\n        <playlist-script>",
          position: (115, 44),
         },
         Expression {
          expression: Variable {
           identifier: "pkg",
           position: (116, 28),
          },
         },
         Raw {
          content: "/share/",
          position: (116, 32),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (116, 41),
          },
         },
         Raw {
          content: "/js/playlists.js</playlist-script>\n        <virtual-layout type=\"builtin\">\n          <import-script>",
          position: (116, 46),
         },
         Expression {
          expression: Variable {
           identifier: "pkg",
           position: (118, 28),
          },
         },
         Raw {
          content: "/share/",
          position: (118, 32),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (118, 41),
          },
         },
         Raw {
          content: "/js/import.js</import-script>\n        </virtual-layout>\n      </scripting>\n      <mappings>\n        <extension-mimetype ignore-unknown=\"no\">\n          <map from=\"mp3\" to=\"audio/mpeg\"/>\n          <map from=\"ogx\" to=\"application/ogg\"/>\n          <map from=\"ogv\" to=\"video/ogg\"/>\n          <map from=\"oga\" to=\"audio/ogg\"/>\n          <map from=\"ogg\" to=\"audio/ogg\"/>\n          <map from=\"ogm\" to=\"video/ogg\"/>\n          <map from=\"asf\" to=\"video/x-ms-asf\"/>\n          <map from=\"asx\" to=\"video/x-ms-asf\"/>\n          <map from=\"wma\" to=\"audio/x-ms-wma\"/>\n          <map from=\"wax\" to=\"audio/x-ms-wax\"/>\n          <map from=\"wmv\" to=\"video/x-ms-wmv\"/>\n          <map from=\"wvx\" to=\"video/x-ms-wvx\"/>\n          <map from=\"wm\" to=\"video/x-ms-wm\"/>\n          <map from=\"wmx\" to=\"video/x-ms-wmx\"/>\n          <map from=\"m3u\" to=\"audio/x-mpegurl\"/>\n          <map from=\"pls\" to=\"audio/x-scpls\"/>\n          <map from=\"flv\" to=\"video/x-flv\"/>\n          <map from=\"mkv\" to=\"video/x-matroska\"/>\n          <map from=\"mka\" to=\"audio/x-matroska\"/>\n          ",
          position: (118, 46),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (142, 13),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (142, 28),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "ps3Support",
                position: (142, 32),
               },
              ],
             },
             default: None,
            },
            String {
             parts: [
              Raw {
               content: "<map from=\"avi\" to=\"video/divx\"/>\n",
               position: (143, 1),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n          ",
          position: (144, 14),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (145, 13),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (145, 28),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "dsmSupport",
                position: (145, 32),
               },
              ],
             },
             default: None,
            },
            String {
             parts: [
              Raw {
               content: "<map from=\"avi\" to=\"video/avi\"/>\n",
               position: (146, 1),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n        </extension-mimetype>\n        <mimetype-upnpclass>\n          <map from=\"audio/*\" to=\"object.item.audioItem.musicTrack\"/>\n          <map from=\"video/*\" to=\"object.item.videoItem\"/>\n          <map from=\"image/*\" to=\"object.item.imageItem\"/>\n        </mimetype-upnpclass>\n        <mimetype-contenttype>\n          <treat mimetype=\"audio/mpeg\" as=\"mp3\"/>\n          <treat mimetype=\"application/ogg\" as=\"ogg\"/>\n          <treat mimetype=\"audio/ogg\" as=\"ogg\"/>\n          <treat mimetype=\"audio/x-flac\" as=\"flac\"/>\n          <treat mimetype=\"audio/x-ms-wma\" as=\"wma\"/>\n          <treat mimetype=\"audio/x-wavpack\" as=\"wv\"/>\n          <treat mimetype=\"image/jpeg\" as=\"jpg\"/>\n          <treat mimetype=\"audio/x-mpegurl\" as=\"playlist\"/>\n          <treat mimetype=\"audio/x-scpls\" as=\"playlist\"/>\n          <treat mimetype=\"audio/x-wav\" as=\"pcm\"/>\n          <treat mimetype=\"audio/L16\" as=\"pcm\"/>\n          <treat mimetype=\"video/x-msvideo\" as=\"avi\"/>\n          <treat mimetype=\"video/mp4\" as=\"mp4\"/>\n          <treat mimetype=\"audio/mp4\" as=\"mp4\"/>\n          <treat mimetype=\"application/x-iso9660\" as=\"dvd\"/>\n          <treat mimetype=\"application/x-iso9660-image\" as=\"dvd\"/>\n        </mimetype-contenttype>\n      </mappings>\n      <online-content>\n        <YouTube enabled=\"no\" refresh=\"28800\" update-at-start=\"no\" purge-after=\"604800\" racy-content=\"exclude\" format=\"mp4\" hd=\"no\">\n          <favorites user=\"",
          position: (147, 14),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (175, 30),
          },
         },
         Raw {
          content: "\"/>\n          <standardfeed feed=\"most_viewed\" time-range=\"today\"/>\n          <playlists user=\"",
          position: (175, 35),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (177, 30),
          },
         },
         Raw {
          content: "\"/>\n          <uploads user=\"",
          position: (177, 35),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (178, 28),
          },
         },
         Raw {
          content: "\"/>\n          <standardfeed feed=\"recently_featured\" time-range=\"today\"/>\n        </YouTube>\n      </online-content>\n    </import>\n    ",
          position: (178, 33),
         },
         Expression {
          expression: Variable {
           identifier: "transcodingConfig",
           position: (183, 7),
          },
         },
         Raw {
          content: "\n  </config>\n",
          position: (183, 25),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "defaultFirewallRules",
        position: (186, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "allowedUDPPorts",
           position: (190, 5),
          },
         ],
        },
        List {
         elements: [
          Int {
           value: 1900,
           position: (190, 25),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (190, 30),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "port",
              position: (190, 34),
             },
            ],
           },
           default: None,
          },
         ],
         position: (190, 23),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "allowedTCPPorts",
           position: (191, 5),
          },
         ],
        },
        List {
         elements: [
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (191, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "port",
              position: (191, 29),
             },
            ],
           },
           default: None,
          },
         ],
         position: (191, 23),
        },
       ),
      ],
      recursive: false,
      position: (186, 26),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (198, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (200, 5),
           },
           Raw {
            content: "mediatomb",
            position: (200, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (202, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (202, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (203, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (203, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (203, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (204, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (204, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (205, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable the Gerbera/Mediatomb DLNA server.\n",
                    position: (206, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (202, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "serverName",
               position: (210, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (210, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (211, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (211, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (211, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (212, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Gerbera (Mediatomb)",
                    position: (212, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (213, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How to identify the server on the network.\n",
                    position: (214, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (210, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (218, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (218, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (219, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (219, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (219, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (220, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (220, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "gerbera",
                     position: (220, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (221, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (221, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gerbera",
                      position: (221, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (222, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Underlying package to be used with the module.\n",
                    position: (223, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (218, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "ps3Support",
               position: (227, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (227, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (228, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (228, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (228, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (229, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (229, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (230, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable ps3 specific tweaks.\nWARNING: incompatible with DSM 320 support.\n",
                    position: (231, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (227, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dsmSupport",
               position: (236, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (236, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (237, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (237, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (237, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (238, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (238, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (239, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable D-Link DSM 320 specific tweaks.\nWARNING: incompatible with ps3 support.\n",
                    position: (240, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (236, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tg100Support",
               position: (245, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (245, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (246, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (246, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (246, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (247, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (247, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (248, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable Telegent TG100 specific tweaks.\n",
                    position: (249, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (245, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "transcoding",
               position: (253, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (253, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (254, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (254, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (254, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (255, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (255, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (256, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable transcoding.\n",
                    position: (257, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (253, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dataDir",
               position: (261, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (261, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (262, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (262, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (262, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (263, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/",
                    position: (263, 20),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "name",
                     position: (263, 31),
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (264, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (264, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"/var/lib/",
                      position: (264, 43),
                     },
                     Raw {
                      content: "$",
                      position: (264, 53),
                     },
                     Raw {
                      content: "{config.",
                      position: (264, 56),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (264, 66),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "package",
                          position: (264, 70),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: ".pname}\"",
                      position: (264, 78),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (265, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The directory where Gerbera/Mediatomb stores its state, data, etc.\n",
                    position: (266, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (261, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pcDirectoryHide",
               position: (270, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (270, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (271, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (271, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (271, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (272, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (272, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (273, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to list the top-level directory or not (from upnp client standpoint).\n",
                    position: (274, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (270, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (278, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (278, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (279, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (279, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (279, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (280, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mediatomb",
                    position: (280, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (281, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User account under which the service runs.",
                    position: (281, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (278, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (284, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (284, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (285, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (285, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (285, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (286, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mediatomb",
                    position: (286, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (287, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Group account under which the service runs.",
                    position: (287, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (284, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (290, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (290, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (291, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (291, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (291, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (292, 9),
                   },
                  ],
                 },
                 Int {
                  value: 49152,
                  position: (292, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (293, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The network port to listen on.\n",
                    position: (294, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (290, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interface",
               position: (298, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (298, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (299, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (299, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (299, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (300, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (301, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A specific interface to bind to.\n",
                    position: (302, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (298, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "openFirewall",
               position: (306, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (306, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (307, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (307, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (307, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (308, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (308, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (309, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If false (the default), this is up to the user to declare the firewall rules.\nIf true, this opens port 1900 (tcp and udp) and the port specified by\n<option>sercvices.mediatomb.port</option>.\n\nIf the option <option>services.mediatomb.interface</option> is set,\nthe firewall rules opened are dedicated to that interface. Otherwise,\nthose rules are opened globally.\n",
                    position: (310, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (306, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "uuid",
               position: (320, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (320, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (321, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (321, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (321, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (322, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "fdfc8a4e-a3ad-4c1d-b43d-a2eedb03a687",
                    position: (322, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (323, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A unique (on your network) to identify the server by.\n",
                    position: (324, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (320, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mediaDirectories",
               position: (328, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (328, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (329, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (329, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (329, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (329, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "mediaDirectory",
                       position: (329, 46),
                      },
                     ],
                    },
                   ],
                  },
                  position: (329, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (330, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (330, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (331, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Declare media directories to index.\n",
                    position: (332, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (334, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (335, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/data/pictures",
                         position: (335, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "recursive",
                         position: (335, 38),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (335, 50),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "hidden-files",
                         position: (335, 57),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (335, 72),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (335, 11),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (336, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/data/audio",
                         position: (336, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "recursive",
                         position: (336, 35),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (336, 47),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "hidden-files",
                         position: (336, 53),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (336, 68),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (336, 11),
                   },
                  ],
                  position: (334, 19),
                 },
                ),
               ],
               recursive: false,
               position: (328, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "customCfg",
               position: (340, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (340, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (341, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (341, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (341, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (342, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (342, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (343, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Allow the service to create and use its own config file inside the <literal>dataDir</literal> as\nconfigured by <option>services.mediatomb.dataDir</option>.\nDeactivated by default, the service then runs with the configuration generated from this module.\nOtherwise, when enabled, no service configuration is generated. Gerbera/Mediatomb then starts using\nconfig.xml within the configured <literal>dataDir</literal>. It's up to the user to make a correct\nconfiguration file.\n",
                    position: (344, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (340, 28),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (200, 26),
         },
        ),
       ],
       recursive: false,
       position: (198, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (359, 3),
        },
       ],
      },
      LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "binaryCommand",
            position: (359, 16),
           },
          ],
         },
         String {
          parts: [
           Expression {
            expression: Variable {
             identifier: "pkg",
             position: (359, 35),
            },
           },
           Raw {
            content: "/bin/",
            position: (359, 39),
           },
           Expression {
            expression: Variable {
             identifier: "name",
             position: (359, 46),
            },
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "interfaceFlag",
            position: (360, 16),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "optionalString",
           position: (360, 32),
          },
          arguments: [
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (360, 49),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "interface",
                 position: (360, 53),
                },
               ],
              },
              default: None,
             },
             String {
              parts: [],
             },
            ],
            position: (360, 63),
           },
           String {
            parts: [
             Raw {
              content: "--interface ",
              position: (360, 71),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (360, 85),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "interface",
                  position: (360, 89),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "configFlag",
            position: (361, 16),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "optionalString",
           position: (361, 29),
          },
          arguments: [
           UnaryOperation {
            operator: Not,
            operand: PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (361, 47),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "customCfg",
                position: (361, 51),
               },
              ],
             },
             default: None,
            },
            position: (361, 45),
           },
           String {
            parts: [
             Raw {
              content: "--config ",
              position: (361, 63),
             },
             Expression {
              expression: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (361, 74),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "writeText",
                   position: (361, 79),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "config.xml",
                   position: (361, 90),
                  },
                 ],
                },
                Variable {
                 identifier: "configText",
                 position: (361, 102),
                },
               ],
              },
             },
            ],
           },
          ],
         },
        ),
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "mkIf",
         position: (362, 8),
        },
        arguments: [
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (362, 13),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "enable",
             position: (362, 17),
            },
           ],
          },
          default: None,
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "systemd",
               position: (363, 5),
              },
              Raw {
               content: "services",
               position: (363, 13),
              },
              Raw {
               content: "mediatomb",
               position: (363, 22),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (364, 7),
                 },
                ],
               },
               String {
                parts: [
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (364, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "serverName",
                      position: (364, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: " media Server",
                  position: (364, 39),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "after",
                  position: (365, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "network.target",
                    position: (365, 18),
                   },
                  ],
                 },
                ],
                position: (365, 15),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "wantedBy",
                  position: (366, 7),
                 },
                ],
               },
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "multi-user.target",
                    position: (366, 21),
                   },
                  ],
                 },
                ],
                position: (366, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceConfig",
                  position: (367, 7),
                 },
                 Raw {
                  content: "ExecStart",
                  position: (367, 21),
                 },
                ],
               },
               String {
                parts: [
                 Expression {
                  expression: Variable {
                   identifier: "binaryCommand",
                   position: (367, 36),
                  },
                 },
                 Raw {
                  content: " --port ",
                  position: (367, 50),
                 },
                 Expression {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "toString",
                    position: (367, 60),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (367, 69),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "port",
                        position: (367, 73),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 },
                 Raw {
                  content: " ",
                  position: (367, 78),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "interfaceFlag",
                   position: (367, 81),
                  },
                 },
                 Raw {
                  content: " ",
                  position: (367, 95),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "configFlag",
                   position: (367, 98),
                  },
                 },
                 Raw {
                  content: " --home ",
                  position: (367, 109),
                 },
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (367, 119),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "dataDir",
                      position: (367, 123),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceConfig",
                  position: (368, 7),
                 },
                 Raw {
                  content: "User",
                  position: (368, 21),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (368, 28),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "user",
                   position: (368, 32),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "serviceConfig",
                  position: (369, 7),
                 },
                 Raw {
                  content: "Group",
                  position: (369, 21),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (369, 29),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "group",
                   position: (369, 33),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (363, 34),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (372, 5),
              },
              Raw {
               content: "groups",
               position: (372, 11),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalAttrs",
              position: (372, 20),
             },
             arguments: [
              BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (372, 35),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "group",
                    position: (372, 39),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "mediatomb",
                   position: (372, 49),
                  },
                 ],
                },
               ],
               position: (372, 45),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "mediatomb",
                    position: (373, 7),
                   },
                   Raw {
                    content: "gid",
                    position: (373, 17),
                   },
                  ],
                 },
                 Variable {
                  identifier: "gid",
                  position: (373, 23),
                 },
                ),
               ],
               recursive: false,
               position: (372, 61),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (376, 5),
              },
              Raw {
               content: "users",
               position: (376, 11),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalAttrs",
              position: (376, 19),
             },
             arguments: [
              BinaryOperation {
               operator: EqualTo,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (376, 34),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "user",
                    position: (376, 38),
                   },
                  ],
                 },
                 default: None,
                },
                String {
                 parts: [
                  Raw {
                   content: "mediatomb",
                   position: (376, 47),
                  },
                 ],
                },
               ],
               position: (376, 43),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "mediatomb",
                    position: (377, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "isSystemUser",
                       position: (378, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (378, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (379, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (379, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "group",
                        position: (379, 21),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "home",
                       position: (380, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (380, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "dataDir",
                        position: (380, 20),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "createHome",
                       position: (381, 9),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (381, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (382, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Expression {
                       expression: Variable {
                        identifier: "name",
                        position: (382, 26),
                       },
                      },
                      Raw {
                       content: " DLNA Server User",
                       position: (382, 31),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (377, 19),
                 },
                ),
               ],
               recursive: false,
               position: (376, 59),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "networking",
               position: (387, 5),
              },
              Raw {
               content: "firewall",
               position: (387, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (387, 27),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (388, 8),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (388, 14),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "openFirewall",
                        position: (388, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                    BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (388, 34),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "interface",
                          position: (388, 38),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [],
                      },
                     ],
                     position: (388, 48),
                    },
                   ],
                   position: (388, 31),
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "interfaces",
                        position: (389, 9),
                       },
                       Expression {
                        expression: String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (389, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "interface",
                               position: (389, 27),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                         ],
                        },
                       },
                      ],
                     },
                     Variable {
                      identifier: "defaultFirewallRules",
                      position: (389, 41),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (388, 55),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (391, 8),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (391, 14),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "openFirewall",
                        position: (391, 18),
                       },
                      ],
                     },
                     default: None,
                    },
                    BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (391, 34),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "interface",
                          position: (391, 38),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [],
                      },
                     ],
                     position: (391, 48),
                    },
                   ],
                   position: (391, 31),
                  },
                  Variable {
                   identifier: "defaultFirewallRules",
                   position: (391, 55),
                  },
                 ],
                },
               ],
               position: (387, 35),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (362, 24),
         },
        ],
       },
       position: (359, 12),
      },
     ),
    ],
    recursive: false,
    position: (194, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}