---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "utils",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "lib",
      position: (4, 12),
     },
    ),
    [
     Raw {
      content: "attrValues",
      position: (5, 5),
     },
     Raw {
      content: "literalExpression",
      position: (6, 5),
     },
     Raw {
      content: "mkEnableOption",
      position: (7, 5),
     },
     Raw {
      content: "mkIf",
      position: (8, 5),
     },
     Raw {
      content: "mkOption",
      position: (9, 5),
     },
     Raw {
      content: "types",
      position: (10, 5),
     },
    ],
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "cfg",
       position: (12, 3),
      },
     ],
    },
    PropertyAccess {
     expression: Variable {
      identifier: "config",
      position: (12, 9),
     },
     attribute_path: AttributePath {
      attributes: [
       Raw {
        content: "services",
        position: (12, 16),
       },
       Raw {
        content: "filebeat",
        position: (12, 25),
       },
      ],
     },
     default: None,
    },
   ),
   KeyValue(
    AttributePath {
     attributes: [
      Raw {
       content: "json",
       position: (14, 3),
      },
     ],
    },
    FunctionApplication {
     function: PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (14, 10),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "formats",
         position: (14, 15),
        },
        Raw {
         content: "json",
         position: (14, 23),
        },
       ],
      },
      default: None,
     },
     arguments: [
      Map {
       bindings: [],
       recursive: false,
       position: (14, 28),
      },
     ],
    },
   ),
  ],
  target: Map {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "options",
        position: (17, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "services",
           position: (19, 5),
          },
          Raw {
           content: "filebeat",
           position: (19, 14),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "enable",
              position: (21, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkEnableOption",
             position: (21, 16),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "filebeat",
                position: (21, 32),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "package",
              position: (23, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (23, 17),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (24, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (24, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "package",
                    position: (24, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (25, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (25, 19),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "filebeat",
                    position: (25, 24),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "defaultText",
                   position: (26, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (26, 23),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "pkgs.filebeat",
                     position: (26, 42),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "example",
                   position: (27, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (27, 19),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "pkgs.filebeat7",
                     position: (27, 38),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (28, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "The filebeat package to use.\n",
                   position: (29, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (23, 26),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "inputs",
              position: (33, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (33, 16),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (34, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Inputs specify how Filebeat locates and processes input data.\n\nThis is like <literal>services.filebeat.settings.filebeat.inputs</literal>,\nbut structured as an attribute set. This has the benefit\nthat multiple NixOS modules can contribute settings to a\nsingle filebeat input.\n\nAn input type can be specified multiple times by choosing a\ndifferent <literal>&lt;name></literal> for each, but setting\n<xref linkend=\"opt-services.filebeat.inputs._name_.type\"/>\nto the same value.\n\nSee <link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html\"/>.\n",
                   position: (35, 1),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (49, 9),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (49, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (50, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (50, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrsOf",
                     position: (50, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (50, 31),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "submodule",
                       position: (50, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Function {
                     argument: None,
                     arguments: FunctionArguments {
                      arguments: [
                       FunctionArgument {
                        identifier: "name",
                        default: None,
                       },
                      ],
                      ellipsis: true,
                     },
                     definition: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "freeformType",
                           position: (51, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "json",
                          position: (51, 26),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "type",
                            position: (51, 31),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (52, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (53, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (53, 20),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (54, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (54, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (54, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (55, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "name",
                                 position: (55, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (56, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The input type.\n\nLook for the value after <literal>type:</literal> on\nthe individual input pages linked from\n<link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html\"/>.\n",
                                   position: (57, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (53, 29),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (52, 21),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (50, 63),
                     },
                     position: (50, 48),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "example",
                   position: (66, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (66, 19),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "{\n  journald.id = \"everything\";  # Only for filebeat7\n  log = {\n    enabled = true;\n    paths = [\n      \"/var/log/*.log\"\n    ];\n  };\n};\n",
                     position: (67, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (33, 25),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "modules",
              position: (79, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (79, 17),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (80, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Filebeat modules provide a quick way to get started\nprocessing common log formats. They contain default\nconfigurations, Elasticsearch ingest pipeline definitions,\nand Kibana dashboards to help you implement and deploy a log\nmonitoring solution.\n\nThis is like <literal>services.filebeat.settings.filebeat.modules</literal>,\nbut structured as an attribute set. This has the benefit\nthat multiple NixOS modules can contribute settings to a\nsingle filebeat module.\n\nA module can be specified multiple times by choosing a\ndifferent <literal>&lt;name></literal> for each, but setting\n<xref linkend=\"opt-services.filebeat.modules._name_.module\"/>\nto the same value.\n\nSee <link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html\"/>.\n",
                   position: (81, 1),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (99, 9),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (99, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (100, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (100, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrsOf",
                     position: (100, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (100, 31),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "submodule",
                       position: (100, 37),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Function {
                     argument: None,
                     arguments: FunctionArguments {
                      arguments: [
                       FunctionArgument {
                        identifier: "name",
                        default: None,
                       },
                      ],
                      ellipsis: true,
                     },
                     definition: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "freeformType",
                           position: (101, 11),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "json",
                          position: (101, 26),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "type",
                            position: (101, 31),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (102, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "module",
                              position: (103, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (103, 22),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (104, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (104, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (104, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (105, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "name",
                                 position: (105, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (106, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The name of the module.\n\nLook for the value after <literal>module:</literal> on\nthe individual input pages linked from\n<link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html\"/>.\n",
                                   position: (107, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (103, 31),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (102, 21),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (100, 63),
                     },
                     position: (100, 48),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "example",
                   position: (116, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (116, 19),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "{\n  nginx = {\n    access = {\n      enabled = true;\n      var.paths = [ \"/path/to/log/nginx/access.log*\" ];\n    };\n    error = {\n      enabled = true;\n      var.paths = [ \"/path/to/log/nginx/error.log*\" ];\n    };\n  };\n};\n",
                     position: (117, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (79, 26),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "settings",
              position: (132, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (132, 18),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (133, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (133, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "submodule",
                     position: (133, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "freeformType",
                        position: (134, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "json",
                       position: (134, 26),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (134, 31),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "options",
                        position: (136, 11),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "output",
                           position: (138, 13),
                          },
                          Raw {
                           content: "elasticsearch",
                           position: (138, 20),
                          },
                          Raw {
                           content: "hosts",
                           position: (138, 34),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (138, 42),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (139, 15),
                               },
                              ],
                             },
                             With {
                              expression: Variable {
                               identifier: "types",
                               position: (139, 27),
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "listOf",
                                position: (139, 34),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (139, 41),
                                },
                               ],
                              },
                              position: (139, 22),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (140, 15),
                               },
                              ],
                             },
                             List {
                              elements: [
                               String {
                                parts: [
                                 Raw {
                                  content: "127.0.0.1:9200",
                                  position: (140, 28),
                                 },
                                ],
                               },
                              ],
                              position: (140, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "example",
                                position: (141, 15),
                               },
                              ],
                             },
                             List {
                              elements: [
                               String {
                                parts: [
                                 Raw {
                                  content: "myEShost:9200",
                                  position: (141, 28),
                                 },
                                ],
                               },
                              ],
                              position: (141, 25),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (142, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The list of Elasticsearch nodes to connect to.\n\nThe events are distributed to these nodes in round\nrobin order. If one node becomes unreachable, the\nevent is automatically sent to another node. Each\nElasticsearch node can be defined as a URL or\nIP:PORT. For example:\n<literal>http://192.15.3.2</literal>,\n<literal>https://es.found.io:9230</literal> or\n<literal>192.24.3.2:9300</literal>. If no port is\nspecified, <literal>9200</literal> is used.\n",
                                position: (143, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (138, 51),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "filebeat",
                           position: (157, 13),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "inputs",
                              position: (158, 15),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (158, 24),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (159, 17),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (159, 24),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (159, 30),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "json",
                                    position: (159, 37),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "type",
                                      position: (159, 42),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (160, 17),
                                  },
                                 ],
                                },
                                List {
                                 elements: [],
                                 position: (160, 27),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "internal",
                                   position: (161, 17),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "true",
                                 position: (161, 28),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (162, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Inputs specify how Filebeat locates and processes\ninput data. Use <xref\nlinkend=\"opt-services.filebeat.inputs\"/> instead.\n\nSee <link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html\"/>.\n",
                                   position: (163, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (158, 33),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "modules",
                              position: (170, 15),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (170, 25),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (171, 17),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (171, 24),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (171, 30),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "json",
                                    position: (171, 37),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "type",
                                      position: (171, 42),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (172, 17),
                                  },
                                 ],
                                },
                                List {
                                 elements: [],
                                 position: (172, 27),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "internal",
                                   position: (173, 17),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "true",
                                 position: (173, 28),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (174, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "Filebeat modules provide a quick way to get started\nprocessing common log formats. They contain default\nconfigurations, Elasticsearch ingest pipeline\ndefinitions, and Kibana dashboards to help you\nimplement and deploy a log monitoring solution.\n\nUse <xref linkend=\"opt-services.filebeat.modules\"/> instead.\n\nSee <link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html\"/>.\n",
                                   position: (175, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (170, 34),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (157, 24),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (136, 21),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (133, 32),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (189, 9),
                  },
                 ],
                },
                Map {
                 bindings: [],
                 recursive: false,
                 position: (189, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "example",
                   position: (190, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "literalExpression",
                  position: (190, 19),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "{\n  settings = {\n    output.elasticsearch = {\n      hosts = [ \"myEShost:9200\" ];\n      username = \"filebeat_internal\";\n      password = { _secret = \"/var/keys/elasticsearch_password\"; };\n    };\n    logging.level = \"info\";\n  };\n};\n",
                     position: (191, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (203, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Configuration for filebeat. See\n<link xlink:href=\"https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-reference-yml.html\"/>\nfor supported values.\n\nOptions containing secret data should be set to an attribute\nset containing the attribute <literal>_secret</literal> - a\nstring pointing to a file containing the value the option\nshould be set to. See the example to get a better picture of\nthis: in the resulting\n<filename>filebeat.yml</filename> file, the\n<literal>output.elasticsearch.password</literal>\nkey will be set to the contents of the\n<filename>/var/keys/elasticsearch_password</filename> file.\n",
                   position: (204, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (132, 27),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (19, 25),
        },
       ),
      ],
      recursive: false,
      position: (17, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "config",
        position: (222, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mkIf",
       position: (222, 12),
      },
      arguments: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (222, 17),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "enable",
           position: (222, 21),
          },
         ],
        },
        default: None,
       },
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (224, 5),
            },
            Raw {
             content: "filebeat",
             position: (224, 14),
            },
            Raw {
             content: "settings",
             position: (224, 23),
            },
            Raw {
             content: "filebeat",
             position: (224, 32),
            },
            Raw {
             content: "inputs",
             position: (224, 41),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "attrValues",
            position: (224, 50),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (224, 61),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "inputs",
                position: (224, 65),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "services",
             position: (225, 5),
            },
            Raw {
             content: "filebeat",
             position: (225, 14),
            },
            Raw {
             content: "settings",
             position: (225, 23),
            },
            Raw {
             content: "filebeat",
             position: (225, 32),
            },
            Raw {
             content: "modules",
             position: (225, 41),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "attrValues",
            position: (225, 51),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (225, 62),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "modules",
                position: (225, 66),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "systemd",
             position: (227, 5),
            },
            Raw {
             content: "services",
             position: (227, 13),
            },
            Raw {
             content: "filebeat",
             position: (227, 22),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "description",
                position: (228, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Filebeat log shipper",
                position: (228, 22),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "wantedBy",
                position: (229, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "multi-user.target",
                  position: (229, 21),
                 },
                ],
               },
              ],
              position: (229, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "wants",
                position: (230, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "elasticsearch.service",
                  position: (230, 18),
                 },
                ],
               },
              ],
              position: (230, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "after",
                position: (231, 7),
               },
              ],
             },
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "elasticsearch.service",
                  position: (231, 18),
                 },
                ],
               },
              ],
              position: (231, 15),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "serviceConfig",
                position: (232, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ExecStartPre",
                   position: (233, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (233, 24),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "writeShellScript",
                     position: (233, 29),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "filebeat-exec-pre",
                     position: (233, 47),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "set -euo pipefail\n\numask u=rwx,g=,o=\n\n",
                     position: (234, 1),
                    },
                    Expression {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "utils",
                        position: (238, 13),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "genJqSecretsReplacementSnippet",
                          position: (238, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (239, 15),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "settings",
                           position: (239, 19),
                          },
                         ],
                        },
                        default: None,
                       },
                       String {
                        parts: [
                         Raw {
                          content: "/var/lib/filebeat/filebeat.yml",
                          position: (240, 16),
                         },
                        ],
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "\n",
                     position: (241, 13),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "ExecStart",
                   position: (243, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (244, 1),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (244, 13),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (244, 17),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/filebeat -e \\\n  -c \"/var/lib/filebeat/filebeat.yml\" \\\n  --path.data \"/var/lib/filebeat\"\n",
                   position: (244, 25),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "Restart",
                   position: (248, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "always",
                   position: (248, 20),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "StateDirectory",
                   position: (249, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "filebeat",
                   position: (249, 27),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (232, 23),
             },
            ),
           ],
           recursive: false,
           position: (227, 33),
          },
         ),
        ],
        recursive: false,
        position: (222, 28),
       },
      ],
     },
    ),
   ],
   recursive: false,
   position: (16, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}