---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "thanos",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nullOpt",
        position: (8, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "type",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "description",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mkOption",
         position: (8, 32),
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (9, 5),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (9, 12),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "nullOr",
                 position: (9, 18),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Variable {
               identifier: "type",
               position: (9, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "default",
               position: (10, 5),
              },
             ],
            },
            Variable {
             identifier: "null",
             position: (10, 15),
            },
           ),
           Inherit(
            None,
            [
             Raw {
              content: "description",
              position: (11, 13),
             },
            ],
           ),
          ],
          recursive: false,
          position: (8, 41),
         },
        ],
       },
       position: (8, 19),
      },
      position: (8, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "optionToArgs",
        position: (14, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "v",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "optional",
         position: (14, 28),
        },
        arguments: [
         BinaryOperation {
          operator: NotEqualTo,
          operands: [
           Variable {
            identifier: "v",
            position: (14, 38),
           },
           Variable {
            identifier: "null",
            position: (14, 43),
           },
          ],
          position: (14, 40),
         },
         String {
          parts: [
           Raw {
            content: "--",
            position: (14, 52),
           },
           Expression {
            expression: Variable {
             identifier: "opt",
             position: (14, 56),
            },
           },
           Raw {
            content: "=\"",
            position: (14, 60),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (14, 64),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (14, 73),
              },
             ],
            },
           },
           Raw {
            content: "\"",
            position: (14, 75),
           },
          ],
         },
        ],
       },
       position: (14, 23),
      },
      position: (14, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "flagToArgs",
        position: (15, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "v",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "optional",
         position: (15, 28),
        },
        arguments: [
         Variable {
          identifier: "v",
          position: (15, 37),
         },
         String {
          parts: [
           Raw {
            content: "--",
            position: (15, 51),
           },
           Expression {
            expression: Variable {
             identifier: "opt",
             position: (15, 55),
            },
           },
          ],
         },
        ],
       },
       position: (15, 23),
      },
      position: (15, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "listToArgs",
        position: (16, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "vs",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "map",
         position: (16, 28),
        },
        arguments: [
         Function {
          argument: Some(
           "v",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: String {
           parts: [
            Raw {
             content: "--",
             position: (16, 52),
            },
            Expression {
             expression: Variable {
              identifier: "opt",
              position: (16, 56),
             },
            },
            Raw {
             content: "=\"",
             position: (16, 60),
            },
            Expression {
             expression: Variable {
              identifier: "v",
              position: (16, 64),
             },
            },
            Raw {
             content: "\"",
             position: (16, 66),
            },
           ],
          },
          position: (16, 47),
         },
         Variable {
          identifier: "vs",
          position: (16, 71),
         },
        ],
       },
       position: (16, 23),
      },
      position: (16, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "attrsToArgs",
        position: (17, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "kvs",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mapAttrsToList",
         position: (17, 28),
        },
        arguments: [
         Function {
          argument: Some(
           "k",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Raw {
              content: "--",
              position: (17, 52),
             },
             Expression {
              expression: Variable {
               identifier: "opt",
               position: (17, 56),
              },
             },
             Raw {
              content: "=",
              position: (17, 60),
             },
             Expression {
              expression: Variable {
               identifier: "k",
               position: (17, 63),
              },
             },
             Raw {
              content: "=\\\"",
              position: (17, 65),
             },
             Expression {
              expression: Variable {
               identifier: "v",
               position: (17, 70),
              },
             },
             Raw {
              content: "\\\"",
              position: (17, 72),
             },
            ],
           },
           position: (17, 47),
          },
          position: (17, 44),
         },
         Variable {
          identifier: "kvs",
          position: (17, 78),
         },
        ],
       },
       position: (17, 23),
      },
      position: (17, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkParamDef",
        position: (19, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "type",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "default",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "description",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "mkParam",
          position: (19, 44),
         },
         arguments: [
          Variable {
           identifier: "type",
           position: (19, 52),
          },
          BinaryOperation {
           operator: Addition,
           operands: [
            Variable {
             identifier: "description",
             position: (19, 58),
            },
            String {
             parts: [
              Raw {
               content: "\nDefaults to <literal>",
               position: (20, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (21, 28),
                },
                arguments: [
                 Variable {
                  identifier: "default",
                  position: (21, 37),
                 },
                ],
               },
              },
              Raw {
               content: "</literal> in Thanos\nwhen set to <literal>null</literal>.\n",
               position: (21, 45),
              },
             ],
            },
           ],
           position: (19, 70),
          },
         ],
        },
        position: (19, 31),
       },
       position: (19, 22),
      },
      position: (19, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkParam",
        position: (25, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "type",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "description",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toArgs",
             position: (26, 5),
            },
           ],
          },
          Variable {
           identifier: "optionToArgs",
           position: (26, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "option",
             position: (27, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "nullOpt",
            position: (27, 14),
           },
           arguments: [
            Variable {
             identifier: "type",
             position: (27, 22),
            },
            Variable {
             identifier: "description",
             position: (27, 27),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (25, 32),
       },
       position: (25, 19),
      },
      position: (25, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkFlagParam",
        position: (30, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "description",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "toArgs",
            position: (31, 5),
           },
          ],
         },
         Variable {
          identifier: "flagToArgs",
          position: (31, 14),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "option",
            position: (32, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (32, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (33, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (33, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (33, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (34, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (34, 17),
              },
             ),
             Inherit(
              None,
              [
               Raw {
                content: "description",
                position: (35, 15),
               },
              ],
             ),
            ],
            recursive: false,
            position: (32, 23),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (30, 30),
      },
      position: (30, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkListParam",
        position: (39, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "description",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toArgs",
             position: (40, 5),
            },
           ],
          },
          Function {
           argument: Some(
            "_opt",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "listToArgs",
             position: (40, 20),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (40, 31),
             },
            ],
           },
           position: (40, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "option",
             position: (41, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (41, 14),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (42, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (42, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "listOf",
                    position: (42, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (42, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (42, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (43, 7),
                 },
                ],
               },
               List {
                elements: [],
                position: (43, 17),
               },
              ),
              Inherit(
               None,
               [
                Raw {
                 content: "description",
                 position: (44, 15),
                },
               ],
              ),
             ],
             recursive: false,
             position: (41, 23),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (39, 35),
       },
       position: (39, 22),
      },
      position: (39, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkAttrsParam",
        position: (48, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "description",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "toArgs",
             position: (49, 5),
            },
           ],
          },
          Function {
           argument: Some(
            "_opt",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "attrsToArgs",
             position: (49, 20),
            },
            arguments: [
             Variable {
              identifier: "opt",
              position: (49, 32),
             },
            ],
           },
           position: (49, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "option",
             position: (50, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkOption",
            position: (50, 14),
           },
           arguments: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "type",
                  position: (51, 7),
                 },
                ],
               },
               FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (51, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "attrsOf",
                    position: (51, 20),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (51, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (51, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "default",
                  position: (52, 7),
                 },
                ],
               },
               Map {
                bindings: [],
                recursive: false,
                position: (52, 17),
               },
              ),
              Inherit(
               None,
               [
                Raw {
                 content: "description",
                 position: (53, 15),
                },
               ],
              ),
             ],
             recursive: false,
             position: (50, 23),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (48, 36),
       },
       position: (48, 23),
      },
      position: (48, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkStateDirParam",
        position: (57, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "opt",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "default",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "description",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "toArgs",
              position: (58, 5),
             },
            ],
           },
           Function {
            argument: Some(
             "_opt",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "stateDir",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "optionToArgs",
               position: (58, 30),
              },
              arguments: [
               Variable {
                identifier: "opt",
                position: (58, 43),
               },
               String {
                parts: [
                 Raw {
                  content: "/var/lib/",
                  position: (58, 48),
                 },
                 Expression {
                  expression: Variable {
                   identifier: "stateDir",
                   position: (58, 59),
                  },
                 },
                ],
               },
              ],
             },
             position: (58, 20),
            },
            position: (58, 14),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "option",
              position: (59, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (59, 14),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (60, 7),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (60, 14),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "str",
                    position: (60, 20),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               Inherit(
                None,
                [
                 Raw {
                  content: "default",
                  position: (61, 15),
                 },
                ],
               ),
               Inherit(
                None,
                [
                 Raw {
                  content: "description",
                  position: (62, 15),
                 },
                ],
               ),
              ],
              recursive: false,
              position: (59, 23),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (57, 48),
        },
        position: (57, 35),
       },
       position: (57, 26),
      },
      position: (57, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toYAML",
        position: (66, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "attrs",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (66, 25),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "runCommand",
            position: (66, 30),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "name",
          position: (66, 41),
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "preferLocalBuild",
               position: (67, 5),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (67, 24),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "json",
               position: (68, 5),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (68, 12),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "toFile",
                 position: (68, 21),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Expression {
                 expression: Variable {
                  identifier: "name",
                  position: (68, 31),
                 },
                },
                Raw {
                 content: ".json",
                 position: (68, 36),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "builtins",
                 position: (68, 44),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "toJSON",
                   position: (68, 53),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "attrs",
                 position: (68, 60),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nativeBuildInputs",
               position: (69, 5),
              },
             ],
            },
            List {
             elements: [
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (69, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "remarshal",
                  position: (69, 32),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (69, 25),
            },
           ),
          ],
          recursive: false,
          position: (66, 46),
         },
         String {
          parts: [
           Raw {
            content: "json2yaml -i $json -o $out",
            position: (70, 6),
           },
          ],
         },
        ],
       },
       position: (66, 18),
      },
      position: (66, 12),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "thanos",
        position: (72, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cmd",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Addition,
       operands: [
        String {
         parts: [
          Expression {
           expression: PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (72, 20),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (72, 24),
              },
             ],
            },
            default: None,
           },
          },
          Raw {
           content: "/bin/thanos ",
           position: (72, 32),
          },
          Expression {
           expression: Variable {
            identifier: "cmd",
            position: (72, 46),
           },
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "args",
              position: (73, 10),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (73, 17),
            },
            attribute_path: AttributePath {
             attributes: [
              Expression {
               expression: Variable {
                identifier: "cmd",
                position: (73, 23),
               },
              },
              Raw {
               content: "arguments",
               position: (73, 28),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         target: FunctionApplication {
          function: Variable {
           identifier: "optionalString",
           position: (74, 9),
          },
          arguments: [
           BinaryOperation {
            operator: NotEqualTo,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "length",
               position: (74, 25),
              },
              arguments: [
               Variable {
                identifier: "args",
                position: (74, 32),
               },
              ],
             },
             Int {
              value: 0,
              position: (74, 40),
             },
            ],
            position: (74, 37),
           },
           BinaryOperation {
            operator: Addition,
            operands: [
             String {
              parts: [
               Raw {
                content: " \\\n  ",
                position: (74, 45),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "concatStringsSep",
               position: (75, 10),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: " \\\n  ",
                  position: (75, 28),
                 },
                ],
               },
               Variable {
                identifier: "args",
                position: (75, 37),
               },
              ],
             },
            ],
            position: (74, 54),
           },
          ],
         },
         position: (73, 6),
        },
       ],
       position: (72, 52),
      },
      position: (72, 12),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "argumentsOf",
        position: (77, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cmd",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "concatLists",
        position: (77, 22),
       },
       arguments: [
        FunctionApplication {
         function: Variable {
          identifier: "collect",
          position: (77, 35),
         },
         arguments: [
          Variable {
           identifier: "isList",
           position: (77, 43),
          },
          FunctionApplication {
           function: Variable {
            identifier: "flip",
            position: (78, 6),
           },
           arguments: [
            Variable {
             identifier: "mapParamsRecursive",
             position: (78, 11),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "params",
              position: (78, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Expression {
                expression: Variable {
                 identifier: "cmd",
                 position: (78, 39),
                },
               },
              ],
             },
             default: None,
            },
            Function {
             argument: Some(
              "path",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "param",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "opt",
                    position: (79, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "concatStringsSep",
                   position: (79, 17),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: ".",
                      position: (79, 35),
                     },
                    ],
                   },
                   Variable {
                    identifier: "path",
                    position: (79, 38),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "v",
                    position: (80, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "getAttrFromPath",
                   position: (80, 15),
                  },
                  arguments: [
                   Variable {
                    identifier: "path",
                    position: (80, 31),
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (80, 36),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Expression {
                       expression: Variable {
                        identifier: "cmd",
                        position: (80, 42),
                       },
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               target: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "param",
                  position: (81, 10),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "toArgs",
                    position: (81, 16),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Variable {
                  identifier: "opt",
                  position: (81, 23),
                 },
                 Variable {
                  identifier: "v",
                  position: (81, 27),
                 },
                ],
               },
               position: (79, 7),
              },
              position: (78, 51),
             },
             position: (78, 45),
            },
           ],
          },
         ],
        },
       ],
      },
      position: (77, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkArgumentsOption",
        position: (83, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cmd",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (83, 28),
       },
       arguments: [
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (84, 5),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "types",
              position: (84, 12),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "listOf",
                position: (84, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (84, 25),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (84, 31),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (85, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "argumentsOf",
             position: (85, 15),
            },
            arguments: [
             Variable {
              identifier: "cmd",
              position: (85, 27),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "defaultText",
              position: (86, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "literalDocBook",
             position: (86, 19),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "calculated from <literal>config.services.thanos.",
                position: (87, 1),
               },
               Expression {
                expression: Variable {
                 identifier: "cmd",
                 position: (87, 57),
                },
               },
               Raw {
                content: "</literal>\n",
                position: (87, 61),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (89, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "Arguments to the <literal>thanos ",
              position: (90, 1),
             },
             Expression {
              expression: Variable {
               identifier: "cmd",
               position: (90, 42),
              },
             },
             Raw {
              content: "</literal> command.\n\nDefaults to a list of arguments formed by converting the structured\noptions of <option>services.thanos.",
              position: (90, 46),
             },
             Expression {
              expression: Variable {
               identifier: "cmd",
               position: (93, 44),
              },
             },
             Raw {
              content: "</option> to a list of arguments.\n\nOverriding this option will cause none of the structured options to have\nany effect. So only set this if you know what you're doing!\n",
              position: (93, 48),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (83, 37),
        },
       ],
      },
      position: (83, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mapParamsRecursive",
        position: (100, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "noParam",
           position: (101, 9),
          },
         ],
        },
        Function {
         argument: Some(
          "attr",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: UnaryOperation {
          operator: Not,
          operand: BinaryOperation {
           operator: LogicalAnd,
           operands: [
            HasProperty {
             expression: Variable {
              identifier: "attr",
              position: (101, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toArgs",
                position: (101, 34),
               },
              ],
             },
             position: (101, 32),
            },
            HasProperty {
             expression: Variable {
              identifier: "attr",
              position: (101, 44),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "option",
                position: (101, 51),
               },
              ],
             },
             position: (101, 49),
            },
           ],
           position: (101, 41),
          },
          position: (101, 25),
         },
         position: (101, 19),
        },
       ),
      ],
      target: FunctionApplication {
       function: Variable {
        identifier: "mapAttrsRecursiveCond",
        position: (102, 8),
       },
       arguments: [
        Variable {
         identifier: "noParam",
         position: (102, 30),
        },
       ],
      },
      position: (101, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "paramsToOptions",
        position: (104, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "mapParamsRecursive",
       position: (104, 21),
      },
      arguments: [
       Function {
        argument: Some(
         "_path",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "param",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: PropertyAccess {
          expression: Variable {
           identifier: "param",
           position: (104, 55),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "option",
             position: (104, 61),
            },
           ],
          },
          default: None,
         },
         position: (104, 48),
        },
        position: (104, 41),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "params",
        position: (106, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "log",
           position: (108, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "log",
              position: (110, 7),
             },
             Raw {
              content: "level",
              position: (110, 11),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkParamDef",
             position: (110, 19),
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (110, 31),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "enum",
                  position: (110, 37),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               List {
                elements: [
                 String {
                  parts: [
                   Raw {
                    content: "debug",
                    position: (110, 44),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "info",
                    position: (110, 52),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "warn",
                    position: (110, 59),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "error",
                    position: (110, 66),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "fatal",
                    position: (110, 74),
                   },
                  ],
                 },
                ],
                position: (110, 42),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "info",
                position: (110, 84),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "Log filtering level.\n",
                position: (111, 1),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "log",
              position: (114, 7),
             },
             Raw {
              content: "format",
              position: (114, 11),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkParam",
             position: (114, 20),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "types",
               position: (114, 28),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "str",
                 position: (114, 34),
                },
               ],
              },
              default: None,
             },
             String {
              parts: [
               Raw {
                content: "Log format to use.\n",
                position: (115, 1),
               },
              ],
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (108, 11),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "tracing",
           position: (119, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "cfg",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tracing",
               position: (120, 7),
              },
              Raw {
               content: "config-file",
               position: (120, 15),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "toArgs",
                  position: (121, 9),
                 },
                ],
               },
               Function {
                argument: Some(
                 "_opt",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "path",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "optionToArgs",
                   position: (121, 30),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "tracing.config-file",
                      position: (121, 44),
                     },
                    ],
                   },
                   Variable {
                    identifier: "path",
                    position: (121, 65),
                   },
                  ],
                 },
                 position: (121, 24),
                },
                position: (121, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "option",
                  position: (122, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (122, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (123, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (123, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "nullOr",
                       position: (123, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (123, 37),
                       },
                      ],
                     },
                     position: (123, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (124, 11),
                      },
                     ],
                    },
                    IfThenElse {
                     predicate: BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (124, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "tracing",
                           position: (124, 28),
                          },
                          Raw {
                           content: "config",
                           position: (124, 36),
                          },
                         ],
                        },
                        default: None,
                       },
                       Variable {
                        identifier: "null",
                        position: (124, 46),
                       },
                      ],
                      position: (124, 43),
                     },
                     then: Variable {
                      identifier: "null",
                      position: (124, 56),
                     },
                     else_: FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (125, 26),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "toYAML",
                         position: (125, 36),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "tracing.yaml",
                            position: (125, 44),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (125, 58),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "tracing",
                             position: (125, 62),
                            },
                            Raw {
                             content: "config",
                             position: (125, 70),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                     position: (124, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (126, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (126, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "if config.services.thanos.<cmd>.tracing.config == null then null\nelse toString (toYAML \"tracing.yaml\" config.services.thanos.<cmd>.tracing.config);\n",
                         position: (127, 1),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (130, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to YAML file that contains tracing configuration.\n\nSee format details: <link xlink:href=\"https://thanos.io/tracing.md/#configuration\"/>\n",
                       position: (131, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (122, 27),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (120, 29),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tracing",
               position: (138, 7),
              },
              Raw {
               content: "config",
               position: (138, 15),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "toArgs",
                  position: (140, 11),
                 },
                ],
               },
               Function {
                argument: Some(
                 "_opt",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "_attrs",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: List {
                  elements: [],
                  position: (140, 34),
                 },
                 position: (140, 26),
                },
                position: (140, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "option",
                  position: (141, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "nullOpt",
                 position: (141, 20),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (141, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (141, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Tracing configuration.\n\nWhen not <literal>null</literal> the attribute set gets converted to\na YAML file and stored in the Nix store. The option\n<option>tracing.config-file</option> will default to its path.\n\nIf <option>tracing.config-file</option> is set this option has no effect.\n\nSee format details: <link xlink:href=\"https://thanos.io/tracing.md/#configuration\"/>\n",
                    position: (142, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (139, 9),
            },
           ),
          ],
          recursive: false,
          position: (119, 20),
         },
         position: (119, 15),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "common",
           position: (155, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "cfg",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: BinaryOperation {
          operator: Update,
          operands: [
           PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (155, 19),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "log",
               position: (155, 26),
              },
             ],
            },
            default: None,
           },
           BinaryOperation {
            operator: Update,
            operands: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "params",
                position: (155, 33),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "tracing",
                  position: (155, 40),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "cfg",
                position: (155, 48),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "http-address",
                   position: (157, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkParamDef",
                  position: (157, 22),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (157, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (157, 39),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "0.0.0.0:10902",
                     position: (157, 44),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Listen <literal>host:port</literal> for HTTP endpoints.\n",
                     position: (158, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "grpc-address",
                   position: (161, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkParamDef",
                  position: (161, 22),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (161, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (161, 39),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "0.0.0.0:10901",
                     position: (161, 44),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Listen <literal>ip:port</literal> address for gRPC endpoints (StoreAPI).\n\nMake sure this address is routable from other components.\n",
                     position: (162, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "grpc-server-tls-cert",
                   position: (167, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkParam",
                  position: (167, 30),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (167, 38),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (167, 44),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "TLS Certificate for gRPC server, leave blank to disable TLS\n",
                     position: (168, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "grpc-server-tls-key",
                   position: (171, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkParam",
                  position: (171, 29),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (171, 37),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (171, 43),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "TLS Key for the gRPC server, leave blank to disable TLS\n",
                     position: (172, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "grpc-server-tls-client-ca",
                   position: (175, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkParam",
                  position: (175, 35),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (175, 43),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (175, 49),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "TLS CA to verify clients against.\n\nIf no client CA is specified, there is no client verification on server side.\n(tls.NoClientCert)\n",
                     position: (176, 1),
                    },
                   ],
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (155, 55),
             },
            ],
            position: (155, 52),
           },
          ],
          position: (155, 30),
         },
         position: (155, 14),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "objstore",
           position: (183, 5),
          },
         ],
        },
        Function {
         argument: Some(
          "cfg",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "objstore",
               position: (185, 7),
              },
              Raw {
               content: "config-file",
               position: (185, 16),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "toArgs",
                  position: (186, 9),
                 },
                ],
               },
               Function {
                argument: Some(
                 "_opt",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "path",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: FunctionApplication {
                  function: Variable {
                   identifier: "optionToArgs",
                   position: (186, 30),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "objstore.config-file",
                      position: (186, 44),
                     },
                    ],
                   },
                   Variable {
                    identifier: "path",
                    position: (186, 66),
                   },
                  ],
                 },
                 position: (186, 24),
                },
                position: (186, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "option",
                  position: (187, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (187, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (188, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (188, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "nullOr",
                       position: (188, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (188, 37),
                       },
                      ],
                     },
                     position: (188, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (189, 11),
                      },
                     ],
                    },
                    IfThenElse {
                     predicate: BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (189, 24),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "objstore",
                           position: (189, 28),
                          },
                          Raw {
                           content: "config",
                           position: (189, 37),
                          },
                         ],
                        },
                        default: None,
                       },
                       Variable {
                        identifier: "null",
                        position: (189, 47),
                       },
                      ],
                      position: (189, 44),
                     },
                     then: Variable {
                      identifier: "null",
                      position: (189, 57),
                     },
                     else_: FunctionApplication {
                      function: Variable {
                       identifier: "toString",
                       position: (190, 26),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "toYAML",
                         position: (190, 36),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "objstore.yaml",
                            position: (190, 44),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (190, 59),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "objstore",
                             position: (190, 63),
                            },
                            Raw {
                             content: "config",
                             position: (190, 72),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                     position: (189, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "defaultText",
                       position: (191, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "literalExpression",
                      position: (191, 25),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "if config.services.thanos.<cmd>.objstore.config == null then null\nelse toString (toYAML \"objstore.yaml\" config.services.thanos.<cmd>.objstore.config);\n",
                         position: (192, 1),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (195, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Path to YAML file that contains object store configuration.\n\nSee format details: <link xlink:href=\"https://thanos.io/storage.md/#configuration\"/>\n",
                       position: (196, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (187, 27),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (185, 30),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "objstore",
               position: (203, 7),
              },
              Raw {
               content: "config",
               position: (203, 16),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "toArgs",
                  position: (205, 11),
                 },
                ],
               },
               Function {
                argument: Some(
                 "_opt",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "_attrs",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: List {
                  elements: [],
                  position: (205, 34),
                 },
                 position: (205, 26),
                },
                position: (205, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "option",
                  position: (206, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "nullOpt",
                 position: (206, 20),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (206, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (206, 34),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Object store configuration.\n\nWhen not <literal>null</literal> the attribute set gets converted to\na YAML file and stored in the Nix store. The option\n<option>objstore.config-file</option> will default to its path.\n\nIf <option>objstore.config-file</option> is set this option has no effect.\n\nSee format details: <link xlink:href=\"https://thanos.io/storage.md/#configuration\"/>\n",
                    position: (207, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (204, 9),
            },
           ),
          ],
          recursive: false,
          position: (183, 21),
         },
         position: (183, 16),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "sidecar",
           position: (220, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (220, 15),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "common",
               position: (220, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (220, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "sidecar",
                position: (220, 33),
               },
              ],
             },
             default: None,
            },
           ],
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (220, 44),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "objstore",
                 position: (220, 51),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (220, 60),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "sidecar",
                  position: (220, 64),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "prometheus",
                  position: (222, 7),
                 },
                 Raw {
                  content: "url",
                  position: (222, 18),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (222, 24),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (222, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (222, 41),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "http://localhost:9090",
                    position: (222, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "URL at which to reach Prometheus's API.\n\nFor better performance use local network.\n",
                    position: (223, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "tsdb",
                  position: (228, 7),
                 },
                 Raw {
                  content: "path",
                  position: (228, 12),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "toArgs",
                     position: (229, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "optionToArgs",
                   position: (229, 18),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "option",
                     position: (230, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkOption",
                    position: (230, 18),
                   },
                   arguments: [
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "type",
                          position: (231, 11),
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (231, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "str",
                           position: (231, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "default",
                          position: (232, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "/var/lib/",
                          position: (232, 22),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (232, 33),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "services",
                              position: (232, 40),
                             },
                             Raw {
                              content: "prometheus",
                              position: (232, 49),
                             },
                             Raw {
                              content: "stateDir",
                              position: (232, 60),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/data",
                          position: (232, 69),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "defaultText",
                          position: (233, 11),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "literalExpression",
                         position: (233, 25),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "\"/var/lib/",
                            position: (233, 45),
                           },
                           Raw {
                            content: "$",
                            position: (233, 55),
                           },
                           Raw {
                            content: "{config.services.prometheus.stateDir}/data\"",
                            position: (233, 58),
                           },
                          ],
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "description",
                          position: (234, 11),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Data directory of TSDB.\n",
                          position: (235, 1),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (230, 27),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (228, 19),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "reloader",
                  position: (240, 7),
                 },
                 Raw {
                  content: "config-file",
                  position: (240, 16),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (240, 30),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (240, 38),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (240, 44),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Config file watched by the reloader.\n",
                    position: (241, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "reloader",
                  position: (244, 7),
                 },
                 Raw {
                  content: "config-envsubst-file",
                  position: (244, 16),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (244, 39),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (244, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (244, 53),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Output file for environment variable substituted config file.\n",
                    position: (245, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "reloader",
                  position: (248, 7),
                 },
                 Raw {
                  content: "rule-dirs",
                  position: (248, 16),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (248, 28),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "reloader.rule-dir",
                    position: (248, 41),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Rule directories for the reloader to refresh.\n",
                    position: (249, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (220, 75),
            },
           ],
           position: (220, 72),
          },
         ],
         position: (220, 41),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "store",
           position: (254, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (254, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "common",
               position: (254, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (254, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (254, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (254, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "objstore",
                 position: (254, 47),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (254, 56),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "store",
                  position: (254, 60),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "stateDir",
                  position: (256, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkStateDirParam",
                 position: (256, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "data-dir",
                    position: (256, 35),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "thanos-store",
                    position: (256, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Data directory relative to <literal>/var/lib</literal>\nin which to cache remote blocks.\n",
                    position: (257, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "index-cache-size",
                  position: (261, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (261, 26),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (261, 37),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (261, 43),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "250MB",
                    position: (261, 48),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum size of items held in the index cache.\n",
                    position: (262, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "chunk-pool-size",
                  position: (265, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (265, 25),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (265, 36),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (265, 42),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "2GB",
                    position: (265, 47),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum size of concurrently allocatable bytes for chunks.\n",
                    position: (266, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "store",
                  position: (269, 7),
                 },
                 Raw {
                  content: "grpc",
                  position: (269, 13),
                 },
                 Raw {
                  content: "series-sample-limit",
                  position: (269, 18),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (269, 40),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (269, 51),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (269, 57),
                    },
                   ],
                  },
                  default: None,
                 },
                 Int {
                  value: 0,
                  position: (269, 61),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum amount of samples returned via a single Series call.\n\n<literal>0</literal> means no limit.\n\nNOTE: for efficiency we take 120 as the number of samples in chunk (it\ncannot be bigger than that), so the actual number of samples might be\nlower, even though the maximum could be hit.\n",
                    position: (270, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "store",
                  position: (279, 7),
                 },
                 Raw {
                  content: "grpc",
                  position: (279, 13),
                 },
                 Raw {
                  content: "series-max-concurrency",
                  position: (279, 18),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (279, 43),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (279, 54),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (279, 60),
                    },
                   ],
                  },
                  default: None,
                 },
                 Int {
                  value: 20,
                  position: (279, 64),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Maximum number of concurrent Series calls.\n",
                    position: (280, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "sync-block-duration",
                  position: (283, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (283, 29),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (283, 40),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (283, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "3m",
                    position: (283, 51),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Repeat interval for syncing the blocks between local and remote view.\n",
                    position: (284, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "block-sync-concurrency",
                  position: (287, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (287, 32),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (287, 43),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (287, 49),
                    },
                   ],
                  },
                  default: None,
                 },
                 Int {
                  value: 20,
                  position: (287, 53),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of goroutines to use when syncing blocks from object storage.\n",
                    position: (288, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "min-time",
                  position: (291, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (291, 18),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (291, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (291, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0000-01-01T00:00:00Z",
                    position: (291, 40),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Start of time range limit to serve.\n\nThanos Store serves only metrics, which happened later than this\nvalue. Option can be a constant time in RFC3339 format or time duration\nrelative to current time, such as -1d or 2h45m. Valid duration units are\nms, s, m, h, d, w, y.\n",
                    position: (292, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "max-time",
                  position: (300, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (300, 18),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (300, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (300, 35),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "9999-12-31T23:59:59Z",
                    position: (300, 40),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "End of time range limit to serve.\n\nThanos Store serves only blocks, which happened eariler than this\nvalue. Option can be a constant time in RFC3339 format or time duration\nrelative to current time, such as -1d or 2h45m. Valid duration units are\nms, s, m, h, d, w, y.\n",
                    position: (301, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (254, 69),
            },
           ],
           position: (254, 66),
          },
         ],
         position: (254, 37),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "query",
           position: (310, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (310, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "common",
               position: (310, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (310, 27),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (310, 31),
               },
              ],
             },
             default: None,
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "grpc-client-tls-secure",
                position: (312, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkFlagParam",
               position: (312, 32),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "Use TLS when talking to the gRPC server\n",
                  position: (313, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "grpc-client-tls-cert",
                position: (316, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (316, 30),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (316, 38),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (316, 44),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "TLS Certificates to use to identify this client to the server\n",
                  position: (317, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "grpc-client-tls-key",
                position: (320, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (320, 29),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (320, 37),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (320, 43),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "TLS Key for the client's certificate\n",
                  position: (321, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "grpc-client-tls-ca",
                position: (324, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (324, 28),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (324, 36),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (324, 42),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "TLS CA Certificates to use to verify gRPC servers\n",
                  position: (325, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "grpc-client-server-name",
                position: (328, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (328, 33),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (328, 41),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (328, 47),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "Server name to verify the hostname on the returned gRPC certificates.\nSee <link xlink:href=\"https://tools.ietf.org/html/rfc4366#section-3.1\"/>\n",
                  position: (329, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "web",
                position: (333, 7),
               },
               Raw {
                content: "route-prefix",
                position: (333, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (333, 26),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (333, 34),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (333, 40),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "Prefix for API and UI endpoints.\n\nThis allows thanos UI to be served on a sub-path. This option is\nanalogous to <option>web.route-prefix</option> of Promethus.\n",
                  position: (334, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "web",
                position: (340, 7),
               },
               Raw {
                content: "external-prefix",
                position: (340, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (340, 29),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (340, 37),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (340, 43),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "Static prefix for all HTML links and redirect URLs in the UI query web\ninterface.\n\nActual endpoints are still served on / or the\n<option>web.route-prefix</option>. This allows thanos UI to be served\nbehind a reverse proxy that strips a URL sub-path.\n",
                  position: (341, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "web",
                position: (349, 7),
               },
               Raw {
                content: "prefix-header",
                position: (349, 11),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (349, 27),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (349, 35),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (349, 41),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "Name of HTTP request header used for dynamic prefixing of UI links and\nredirects.\n\nThis option is ignored if the option\n<literal>web.external-prefix</literal> is set.\n\nSecurity risk: enable this option only if a reverse proxy in front of\nthanos is resetting the header.\n\nThe setting <literal>web.prefix-header=\"X-Forwarded-Prefix\"</literal>\ncan be useful, for example, if Thanos UI is served via Traefik reverse\nproxy with <literal>PathPrefixStrip</literal> option enabled, which\nsends the stripped prefix value in <literal>X-Forwarded-Prefix</literal>\nheader. This allows thanos UI to be served on a sub-path.\n",
                  position: (350, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (366, 7),
               },
               Raw {
                content: "timeout",
                position: (366, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (366, 23),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (366, 34),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (366, 40),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "2m",
                  position: (366, 45),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Maximum time to process query by query node.\n",
                  position: (367, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (370, 7),
               },
               Raw {
                content: "max-concurrent",
                position: (370, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (370, 30),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (370, 41),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "int",
                   position: (370, 47),
                  },
                 ],
                },
                default: None,
               },
               Int {
                value: 20,
                position: (370, 51),
               },
               String {
                parts: [
                 Raw {
                  content: "Maximum number of queries processed concurrently by query node.\n",
                  position: (371, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (374, 7),
               },
               Raw {
                content: "replica-label",
                position: (374, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParam",
               position: (374, 29),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (374, 37),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (374, 43),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "Label to treat as a replica indicator along which data is\ndeduplicated.\n\nStill you will be able to query without deduplication using\n<literal>dedup=false</literal> parameter.\n",
                  position: (375, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "selector-labels",
                position: (382, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkAttrsParam",
               position: (382, 25),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "selector-label",
                  position: (382, 39),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Query selector labels that will be exposed in info endpoint.\n",
                  position: (383, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (386, 7),
               },
               Raw {
                content: "addresses",
                position: (386, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkListParam",
               position: (386, 25),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "store",
                  position: (386, 38),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Addresses of statically configured store API servers.\n\nThe scheme may be prefixed with <literal>dns+</literal> or\n<literal>dnssrv+</literal> to detect store API servers through\nrespective DNS lookups.\n",
                  position: (387, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (394, 7),
               },
               Raw {
                content: "sd-files",
                position: (394, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkListParam",
               position: (394, 24),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "store.sd-files",
                  position: (394, 37),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Path to files that contain addresses of store API servers. The path\ncan be a glob pattern.\n",
                  position: (395, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (399, 7),
               },
               Raw {
                content: "sd-interval",
                position: (399, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (399, 27),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (399, 38),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (399, 44),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "5m",
                  position: (399, 49),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Refresh interval to re-read file SD files. It is used as a resync fallback.\n",
                  position: (400, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (403, 7),
               },
               Raw {
                content: "sd-dns-interval",
                position: (403, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (403, 31),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (403, 42),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (403, 48),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "30s",
                  position: (403, 53),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Interval between DNS resolutions.\n",
                  position: (404, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (407, 7),
               },
               Raw {
                content: "unhealthy-timeout",
                position: (407, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (407, 33),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (407, 44),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (407, 50),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "5m",
                  position: (407, 55),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Timeout before an unhealthy store is cleaned from the store UI page.\n",
                  position: (408, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (411, 7),
               },
               Raw {
                content: "auto-downsampling",
                position: (411, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkFlagParam",
               position: (411, 33),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "Enable automatic adjustment (step / 5) to what source of data should\nbe used in store gateways if no\n<literal>max_source_resolution</literal> param is specified.\n",
                  position: (412, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (417, 7),
               },
               Raw {
                content: "partial-response",
                position: (417, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkFlagParam",
               position: (417, 32),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "Enable partial response for queries if no\n<literal>partial_response</literal> param is specified.\n",
                  position: (418, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (422, 7),
               },
               Raw {
                content: "default-evaluation-interval",
                position: (422, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (422, 43),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (422, 54),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (422, 60),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "1m",
                  position: (422, 65),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Set default evaluation interval for sub queries.\n",
                  position: (423, 1),
                 },
                ],
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (426, 7),
               },
               Raw {
                content: "response-timeout",
                position: (426, 13),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkParamDef",
               position: (426, 32),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (426, 43),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "str",
                   position: (426, 49),
                  },
                 ],
                },
                default: None,
               },
               String {
                parts: [
                 Raw {
                  content: "0ms",
                  position: (426, 54),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "If a Store doesn't send any data in this specified duration then a\nStore will be ignored and partial data will be returned if it's\nenabled. <literal>0</literal> disables timeout.\n",
                  position: (427, 1),
                 },
                ],
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (310, 40),
          },
         ],
         position: (310, 37),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "rule",
           position: (433, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (433, 12),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "common",
               position: (433, 19),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (433, 26),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "rule",
                position: (433, 30),
               },
              ],
             },
             default: None,
            },
           ],
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (433, 38),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "objstore",
                 position: (433, 45),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (433, 54),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "rule",
                  position: (433, 58),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "labels",
                  position: (435, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkAttrsParam",
                 position: (435, 16),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "label",
                    position: (435, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Labels to be applied to all generated metrics.\n\nSimilar to external labels for Prometheus,\nused to identify ruler and its blocks as unique source.\n",
                    position: (436, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "stateDir",
                  position: (442, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkStateDirParam",
                 position: (442, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "data-dir",
                    position: (442, 35),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "thanos-rule",
                    position: (442, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Data directory relative to <literal>/var/lib</literal>.\n",
                    position: (443, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rule-files",
                  position: (446, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (446, 20),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "rule-file",
                    position: (446, 33),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Rule files that should be used by rule manager. Can be in glob format.\n",
                    position: (447, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "eval-interval",
                  position: (450, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (450, 23),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (450, 34),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (450, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "30s",
                    position: (450, 45),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The default evaluation interval to use.\n",
                    position: (451, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "tsdb",
                  position: (454, 7),
                 },
                 Raw {
                  content: "block-duration",
                  position: (454, 12),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (454, 29),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (454, 40),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (454, 46),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "2h",
                    position: (454, 51),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Block duration for TSDB block.\n",
                    position: (455, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "tsdb",
                  position: (458, 7),
                 },
                 Raw {
                  content: "retention",
                  position: (458, 12),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (458, 24),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (458, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (458, 41),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "48h",
                    position: (458, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Block retention time on local disk.\n",
                    position: (459, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "alertmanagers",
                  position: (462, 7),
                 },
                 Raw {
                  content: "urls",
                  position: (462, 21),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (462, 28),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "alertmanagers.url",
                    position: (462, 41),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Alertmanager replica URLs to push firing alerts.\n\nRuler claims success if push to at least one alertmanager from\ndiscovered succeeds. The scheme may be prefixed with\n<literal>dns+</literal> or <literal>dnssrv+</literal> to detect\nAlertmanager IPs through respective DNS lookups. The port defaults to\n<literal>9093</literal> or the SRV record's value. The URL path is\nused as a prefix for the regular Alertmanager API path.\n",
                    position: (463, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "alertmanagers",
                  position: (473, 7),
                 },
                 Raw {
                  content: "send-timeout",
                  position: (473, 21),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (473, 36),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (473, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (473, 53),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "10s",
                    position: (473, 58),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Timeout for sending alerts to alertmanager.\n",
                    position: (474, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "alert",
                  position: (477, 7),
                 },
                 Raw {
                  content: "query-url",
                  position: (477, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (477, 25),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (477, 33),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (477, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The external Thanos Query URL that would be set in all alerts 'Source' field.\n",
                    position: (478, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "alert",
                  position: (481, 7),
                 },
                 Raw {
                  content: "label-drop",
                  position: (481, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (481, 26),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "alert.label-drop",
                    position: (481, 39),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Labels by name to drop before sending to alertmanager.\n\nThis allows alert to be deduplicated on replica label.\n\nSimilar Prometheus alert relabelling\n",
                    position: (482, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "web",
                  position: (489, 7),
                 },
                 Raw {
                  content: "route-prefix",
                  position: (489, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (489, 26),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (489, 34),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (489, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Prefix for API and UI endpoints.\n\nThis allows thanos UI to be served on a sub-path.\n\nThis option is analogous to <literal>--web.route-prefix</literal> of Promethus.\n",
                    position: (490, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "web",
                  position: (497, 7),
                 },
                 Raw {
                  content: "external-prefix",
                  position: (497, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (497, 29),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (497, 37),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (497, 43),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Static prefix for all HTML links and redirect URLs in the UI query web\ninterface.\n\nActual endpoints are still served on / or the\n<option>web.route-prefix</option>. This allows thanos UI to be served\nbehind a reverse proxy that strips a URL sub-path.\n",
                    position: (498, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "web",
                  position: (506, 7),
                 },
                 Raw {
                  content: "prefix-header",
                  position: (506, 11),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParam",
                 position: (506, 27),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (506, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (506, 41),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Name of HTTP request header used for dynamic prefixing of UI links and\nredirects.\n\nThis option is ignored if the option\n<option>web.external-prefix</option> is set.\n\nSecurity risk: enable this option only if a reverse proxy in front of\nthanos is resetting the header.\n\nThe header <literal>X-Forwarded-Prefix</literal> can be useful, for\nexample, if Thanos UI is served via Traefik reverse proxy with\n<literal>PathPrefixStrip</literal> option enabled, which sends the\nstripped prefix value in <literal>X-Forwarded-Prefix</literal>\nheader. This allows thanos UI to be served on a sub-path.\n",
                    position: (507, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "query",
                  position: (523, 7),
                 },
                 Raw {
                  content: "addresses",
                  position: (523, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (523, 25),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "query",
                    position: (523, 38),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Addresses of statically configured query API servers.\n\nThe scheme may be prefixed with <literal>dns+</literal> or\n<literal>dnssrv+</literal> to detect query API servers through\nrespective DNS lookups.\n",
                    position: (524, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "query",
                  position: (531, 7),
                 },
                 Raw {
                  content: "sd-files",
                  position: (531, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkListParam",
                 position: (531, 24),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "query.sd-files",
                    position: (531, 37),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to file that contain addresses of query peers.\nThe path can be a glob pattern.\n",
                    position: (532, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "query",
                  position: (536, 7),
                 },
                 Raw {
                  content: "sd-interval",
                  position: (536, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (536, 27),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (536, 38),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (536, 44),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "5m",
                    position: (536, 49),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Refresh interval to re-read file SD files. (used as a fallback)\n",
                    position: (537, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "query",
                  position: (540, 7),
                 },
                 Raw {
                  content: "sd-dns-interval",
                  position: (540, 13),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (540, 31),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (540, 42),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (540, 48),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "30s",
                    position: (540, 53),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Interval between DNS resolutions.\n",
                    position: (541, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (433, 66),
            },
           ],
           position: (433, 63),
          },
         ],
         position: (433, 35),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "compact",
           position: (545, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "params",
            position: (545, 15),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "log",
              position: (545, 22),
             },
            ],
           },
           default: None,
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (545, 29),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "tracing",
                 position: (545, 36),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (545, 44),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "compact",
                  position: (545, 48),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "params",
                 position: (545, 59),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "objstore",
                   position: (545, 66),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (545, 75),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "compact",
                    position: (545, 79),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "http-address",
                    position: (547, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (547, 22),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (547, 33),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (547, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0.0.0.0:10902",
                      position: (547, 44),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Listen <literal>host:port</literal> for HTTP endpoints.\n",
                      position: (548, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (551, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkStateDirParam",
                   position: (551, 18),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "data-dir",
                      position: (551, 35),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "thanos-compact",
                      position: (551, 46),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Data directory relative to <literal>/var/lib</literal>\nin which to cache blocks and process compactions.\n",
                      position: (552, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "consistency-delay",
                    position: (556, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (556, 27),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (556, 38),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (556, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "30m",
                      position: (556, 49),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Minimum age of fresh (non-compacted) blocks before they are being\nprocessed. Malformed blocks older than the maximum of consistency-delay\nand 30m0s will be removed.\n",
                      position: (557, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "retention",
                    position: (562, 7),
                   },
                   Raw {
                    content: "resolution-raw",
                    position: (562, 17),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (562, 34),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (562, 45),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (562, 51),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0d",
                      position: (562, 56),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "How long to retain raw samples in bucket.\n\n<literal>0d</literal> - disables this retention\n",
                      position: (563, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "retention",
                    position: (568, 7),
                   },
                   Raw {
                    content: "resolution-5m",
                    position: (568, 17),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (568, 33),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (568, 44),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (568, 50),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0d",
                      position: (568, 55),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "How long to retain samples of resolution 1 (5 minutes) in bucket.\n\n<literal>0d</literal> - disables this retention\n",
                      position: (569, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "retention",
                    position: (574, 7),
                   },
                   Raw {
                    content: "resolution-1h",
                    position: (574, 17),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (574, 33),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (574, 44),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (574, 50),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0d",
                      position: (574, 55),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "How long to retain samples of resolution 2 (1 hour) in bucket.\n\n<literal>0d</literal> - disables this retention\n",
                      position: (575, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "startAt",
                    position: (580, 7),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "toArgs",
                       position: (581, 9),
                      },
                     ],
                    },
                    Function {
                     argument: Some(
                      "_opt",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: Function {
                      argument: Some(
                       "startAt",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: FunctionApplication {
                       function: Variable {
                        identifier: "flagToArgs",
                        position: (581, 33),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "wait",
                           position: (581, 45),
                          },
                         ],
                        },
                        BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          Variable {
                           identifier: "startAt",
                           position: (581, 52),
                          },
                          Variable {
                           identifier: "null",
                           position: (581, 63),
                          },
                         ],
                         position: (581, 60),
                        },
                       ],
                      },
                      position: (581, 24),
                     },
                     position: (581, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "option",
                       position: (582, 9),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "nullOpt",
                      position: (582, 18),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (582, 26),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "str",
                          position: (582, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "When this option is set to a <literal>systemd.time</literal>\nspecification the Thanos compactor will run at the specified period.\n\nWhen this option is <literal>null</literal> the Thanos compactor service\nwill run continuously. So it will not exit after all compactions have\nbeen processed but wait for new work.\n",
                         position: (583, 1),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (580, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "downsampling",
                    position: (592, 7),
                   },
                   Raw {
                    content: "disable",
                    position: (592, 20),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkFlagParam",
                   position: (592, 30),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "Disables downsampling.\n\nThis is not recommended as querying long time ranges without\nnon-downsampled data is not efficient and useful e.g it is not possible\nto render all samples for a human eye anyway\n",
                      position: (593, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "block-sync-concurrency",
                    position: (600, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (600, 32),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (600, 43),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (600, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                   Int {
                    value: 20,
                    position: (600, 53),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Number of goroutines to use when syncing block metadata from object storage.\n",
                      position: (601, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "compact",
                    position: (604, 7),
                   },
                   Raw {
                    content: "concurrency",
                    position: (604, 15),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkParamDef",
                   position: (604, 29),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (604, 40),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (604, 46),
                      },
                     ],
                    },
                    default: None,
                   },
                   Int {
                    value: 1,
                    position: (604, 50),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Number of goroutines to use when compacting groups.\n",
                      position: (605, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (545, 90),
              },
             ],
             position: (545, 87),
            },
           ],
           position: (545, 56),
          },
         ],
         position: (545, 26),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "downsample",
           position: (609, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          PropertyAccess {
           expression: Variable {
            identifier: "params",
            position: (609, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "log",
              position: (609, 25),
             },
            ],
           },
           default: None,
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (609, 32),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "tracing",
                 position: (609, 39),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (609, 47),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "downsample",
                  position: (609, 51),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            BinaryOperation {
             operator: Update,
             operands: [
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "params",
                 position: (609, 65),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "objstore",
                   position: (609, 72),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (609, 81),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "downsample",
                    position: (609, 85),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "stateDir",
                    position: (611, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkStateDirParam",
                   position: (611, 18),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "data-dir",
                      position: (611, 35),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "thanos-downsample",
                      position: (611, 46),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Data directory relative to <literal>/var/lib</literal>\nin which to cache blocks and process downsamplings.\n",
                      position: (612, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (609, 99),
              },
             ],
             position: (609, 96),
            },
           ],
           position: (609, 62),
          },
         ],
         position: (609, 29),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "receive",
           position: (618, 5),
          },
         ],
        },
        BinaryOperation {
         operator: Update,
         operands: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "params",
             position: (618, 15),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "common",
               position: (618, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (618, 29),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "receive",
                position: (618, 33),
               },
              ],
             },
             default: None,
            },
           ],
          },
          BinaryOperation {
           operator: Update,
           operands: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (618, 44),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "objstore",
                 position: (618, 51),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (618, 60),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "receive",
                  position: (618, 64),
                 },
                ],
               },
               default: None,
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "remote-write",
                  position: (620, 7),
                 },
                 Raw {
                  content: "address",
                  position: (620, 20),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (620, 30),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (620, 41),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (620, 47),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0.0.0.0:19291",
                    position: (620, 52),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Address to listen on for remote write requests.\n",
                    position: (621, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "stateDir",
                  position: (624, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkStateDirParam",
                 position: (624, 18),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "tsdb.path",
                    position: (624, 35),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "thanos-receive",
                    position: (624, 47),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Data directory relative to <literal>/var/lib</literal> of TSDB.\n",
                    position: (625, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "labels",
                  position: (628, 7),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkAttrsParam",
                 position: (628, 16),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "labels",
                    position: (628, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "External labels to announce.\n\nThis flag will be removed in the future when handling multiple tsdb\ninstances is added.\n",
                    position: (629, 1),
                   },
                  ],
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "tsdb",
                  position: (635, 7),
                 },
                 Raw {
                  content: "retention",
                  position: (635, 12),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkParamDef",
                 position: (635, 24),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (635, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (635, 41),
                    },
                   ],
                  },
                  default: None,
                 },
                 String {
                  parts: [
                   Raw {
                    content: "15d",
                    position: (635, 46),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "How long to retain raw samples on local storage.\n\n<literal>0d</literal> - disables this retention\n",
                    position: (636, 1),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (618, 75),
            },
           ],
           position: (618, 72),
          },
         ],
         position: (618, 41),
        },
       ),
      ],
      recursive: false,
      position: (106, 12),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "assertRelativeStateDir",
        position: (644, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cmd",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "assertions",
            position: (645, 5),
           },
          ],
         },
         List {
          elements: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "assertion",
                 position: (647, 9),
                },
               ],
              },
              UnaryOperation {
               operator: Not,
               operand: FunctionApplication {
                function: Variable {
                 identifier: "hasPrefix",
                 position: (647, 22),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "/",
                    position: (647, 33),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (647, 36),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Expression {
                     expression: Variable {
                      identifier: "cmd",
                      position: (647, 42),
                     },
                    },
                    Raw {
                     content: "stateDir",
                     position: (647, 47),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (647, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "message",
                 position: (648, 9),
                },
               ],
              },
              BinaryOperation {
               operator: Addition,
               operands: [
                String {
                 parts: [
                  Raw {
                   content: "The option services.thanos.",
                   position: (649, 12),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "cmd",
                    position: (649, 41),
                   },
                  },
                  Raw {
                   content: ".stateDir should not be an absolute directory.",
                   position: (649, 45),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: " It should be a directory relative to /var/lib.",
                   position: (650, 12),
                  },
                 ],
                },
               ],
               position: (649, 93),
              },
             ),
            ],
            recursive: false,
            position: (646, 7),
           },
          ],
          position: (645, 18),
         },
        ),
       ],
       recursive: false,
       position: (644, 33),
      },
      position: (644, 28),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (657, 3),
        },
        Raw {
         content: "services",
         position: (657, 11),
        },
        Raw {
         content: "thanos",
         position: (657, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "package",
            position: (659, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (659, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (660, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (660, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (660, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (661, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (661, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "thanos",
                  position: (661, 22),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (662, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (662, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "pkgs.thanos",
                   position: (662, 40),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (663, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The thanos package that should be used.\n",
                 position: (664, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (659, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "sidecar",
            position: (668, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (668, 15),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (668, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "sidecar",
                 position: (668, 38),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (669, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (669, 16),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "the Thanos sidecar for Prometheus server",
                   position: (670, 10),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (671, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (671, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "sidecar",
                   position: (671, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (668, 49),
           },
          ],
          position: (668, 46),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "store",
            position: (674, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (674, 13),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (674, 29),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "store",
                 position: (674, 36),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (675, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (675, 16),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "the Thanos store node giving access to blocks in a bucket provider.",
                   position: (676, 10),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (677, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (677, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "store",
                   position: (677, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (674, 45),
           },
          ],
          position: (674, 42),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "query",
            position: (680, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (680, 13),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (680, 29),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "query",
                 position: (680, 36),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (681, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (681, 16),
               },
               arguments: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "the Thanos query node exposing PromQL enabled Query API ",
                     position: (682, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "with data retrieved from multiple store nodes",
                     position: (683, 11),
                    },
                   ],
                  },
                 ],
                 position: (682, 69),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (684, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (684, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "query",
                   position: (684, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (680, 45),
           },
          ],
          position: (680, 42),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "rule",
            position: (687, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (687, 12),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (687, 28),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "rule",
                 position: (687, 35),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (688, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (688, 16),
               },
               arguments: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "the Thanos ruler service which evaluates Prometheus rules against",
                     position: (689, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: " given Query nodes, exposing Store API and storing old blocks in bucket",
                     position: (690, 10),
                    },
                   ],
                  },
                 ],
                 position: (689, 78),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (691, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (691, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "rule",
                   position: (691, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (687, 43),
           },
          ],
          position: (687, 40),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "compact",
            position: (694, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (694, 15),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (694, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "compact",
                 position: (694, 38),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (695, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (695, 16),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "the Thanos compactor which continuously compacts blocks in an object store bucket",
                   position: (696, 10),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (697, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (697, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "compact",
                   position: (697, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (694, 49),
           },
          ],
          position: (694, 46),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "downsample",
            position: (700, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (700, 18),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (700, 34),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "downsample",
                 position: (700, 41),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (701, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (701, 16),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "the Thanos downsampler which continuously downsamples blocks in an object store bucket",
                   position: (702, 10),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (703, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (703, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "downsample",
                   position: (703, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (700, 55),
           },
          ],
          position: (700, 52),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "receive",
            position: (706, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "paramsToOptions",
             position: (706, 15),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "params",
               position: (706, 31),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "receive",
                 position: (706, 38),
                },
               ],
              },
              default: None,
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enable",
                 position: (707, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkEnableOption",
                position: (707, 16),
               },
               arguments: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "the Thanos receiver which accept Prometheus remote write API requests ",
                     position: (708, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "and write to local tsdb (EXPERIMENTAL, this may change drastically without notice)",
                     position: (709, 11),
                    },
                   ],
                  },
                 ],
                 position: (708, 83),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "arguments",
                 position: (710, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkArgumentsOption",
                position: (710, 19),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "receive",
                   position: (710, 38),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (706, 49),
           },
          ],
          position: (706, 46),
         },
        ),
       ],
       recursive: false,
       position: (657, 29),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (714, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkMerge",
        position: (714, 12),
       },
       arguments: [
        List {
         elements: [
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (716, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (716, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "sidecar",
                position: (716, 15),
               },
               Raw {
                content: "enable",
                position: (716, 23),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "assertions",
                  position: (717, 7),
                 },
                ],
               },
               List {
                elements: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "assertion",
                       position: (719, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (719, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (719, 30),
                       },
                       Raw {
                        content: "prometheus",
                        position: (719, 39),
                       },
                       Raw {
                        content: "enable",
                        position: (719, 50),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "message",
                       position: (720, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Please enable services.prometheus when enabling services.thanos.sidecar.",
                       position: (721, 14),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (718, 9),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "assertion",
                       position: (724, 11),
                      },
                     ],
                    },
                    UnaryOperation {
                     operator: Not,
                     operand: BinaryOperation {
                      operator: LogicalOr,
                      operands: [
                       BinaryOperation {
                        operator: EqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (724, 25),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "services",
                             position: (724, 32),
                            },
                            Raw {
                             content: "prometheus",
                             position: (724, 41),
                            },
                            Raw {
                             content: "globalConfig",
                             position: (724, 52),
                            },
                            Raw {
                             content: "external_labels",
                             position: (724, 65),
                            },
                           ],
                          },
                          default: None,
                         },
                         Variable {
                          identifier: "null",
                          position: (724, 84),
                         },
                        ],
                        position: (724, 81),
                       },
                       BinaryOperation {
                        operator: EqualTo,
                        operands: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (725, 25),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "services",
                             position: (725, 32),
                            },
                            Raw {
                             content: "prometheus",
                             position: (725, 41),
                            },
                            Raw {
                             content: "globalConfig",
                             position: (725, 52),
                            },
                            Raw {
                             content: "external_labels",
                             position: (725, 65),
                            },
                           ],
                          },
                          default: None,
                         },
                         Map {
                          bindings: [],
                          recursive: false,
                          position: (725, 84),
                         },
                        ],
                        position: (725, 81),
                       },
                      ],
                      position: (724, 89),
                     },
                     position: (724, 23),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "message",
                       position: (726, 11),
                      },
                     ],
                    },
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        String {
                         parts: [
                          Raw {
                           content: "services.thanos.sidecar requires uniquely identifying external labels ",
                           position: (727, 14),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "to be configured in the Prometheus server. ",
                           position: (728, 14),
                          },
                         ],
                        },
                       ],
                       position: (727, 86),
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Please set services.prometheus.globalConfig.external_labels.",
                         position: (729, 14),
                        },
                       ],
                      },
                     ],
                     position: (728, 59),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (723, 9),
                 },
                ],
                position: (717, 20),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (732, 7),
                 },
                 Raw {
                  content: "services",
                  position: (732, 15),
                 },
                 Raw {
                  content: "thanos-sidecar",
                  position: (732, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (733, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (733, 23),
                      },
                     ],
                    },
                   ],
                   position: (733, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (734, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (734, 23),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "prometheus.service",
                       position: (734, 40),
                      },
                     ],
                    },
                   ],
                   position: (734, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (735, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (736, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "prometheus",
                        position: (736, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Restart",
                        position: (737, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "always",
                        position: (737, 22),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (738, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "thanos",
                       position: (738, 23),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "sidecar",
                          position: (738, 31),
                         },
                        ],
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (735, 25),
                  },
                 ),
                ],
                recursive: false,
                position: (732, 41),
               },
              ),
             ],
             recursive: false,
             position: (716, 30),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (743, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (743, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "store",
                position: (743, 15),
               },
               Raw {
                content: "enable",
                position: (743, 21),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (743, 29),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assertRelativeStateDir",
                  position: (744, 8),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "store",
                     position: (744, 32),
                    },
                   ],
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "systemd",
                      position: (746, 9),
                     },
                     Raw {
                      content: "services",
                      position: (746, 17),
                     },
                     Raw {
                      content: "thanos-store",
                      position: (746, 26),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wantedBy",
                         position: (747, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (747, 25),
                          },
                         ],
                        },
                       ],
                       position: (747, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "after",
                         position: (748, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "network.target",
                           position: (748, 25),
                          },
                         ],
                        },
                       ],
                       position: (748, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "serviceConfig",
                         position: (749, 11),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "DynamicUser",
                            position: (750, 13),
                           },
                          ],
                         },
                         Variable {
                          identifier: "true",
                          position: (750, 27),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "StateDirectory",
                            position: (751, 13),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (751, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "store",
                             position: (751, 34),
                            },
                            Raw {
                             content: "stateDir",
                             position: (751, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "Restart",
                            position: (752, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "always",
                            position: (752, 24),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "ExecStart",
                            position: (753, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "thanos",
                           position: (753, 25),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "store",
                              position: (753, 33),
                             },
                            ],
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (749, 27),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (746, 41),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (745, 7),
                },
               ],
               position: (743, 37),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (759, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (759, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "query",
                position: (759, 15),
               },
               Raw {
                content: "enable",
                position: (759, 21),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (760, 7),
                 },
                 Raw {
                  content: "services",
                  position: (760, 15),
                 },
                 Raw {
                  content: "thanos-query",
                  position: (760, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (761, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (761, 23),
                      },
                     ],
                    },
                   ],
                   position: (761, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (762, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (762, 23),
                      },
                     ],
                    },
                   ],
                   position: (762, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (763, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "DynamicUser",
                        position: (764, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (764, 25),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Restart",
                        position: (765, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "always",
                        position: (765, 22),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (766, 11),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "thanos",
                       position: (766, 23),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "query",
                          position: (766, 31),
                         },
                        ],
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (763, 25),
                  },
                 ),
                ],
                recursive: false,
                position: (760, 39),
               },
              ),
             ],
             recursive: false,
             position: (759, 28),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (771, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (771, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "rule",
                position: (771, 15),
               },
               Raw {
                content: "enable",
                position: (771, 20),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (771, 28),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assertRelativeStateDir",
                  position: (772, 8),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "rule",
                     position: (772, 32),
                    },
                   ],
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "systemd",
                      position: (774, 9),
                     },
                     Raw {
                      content: "services",
                      position: (774, 17),
                     },
                     Raw {
                      content: "thanos-rule",
                      position: (774, 26),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wantedBy",
                         position: (775, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (775, 25),
                          },
                         ],
                        },
                       ],
                       position: (775, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "after",
                         position: (776, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "network.target",
                           position: (776, 25),
                          },
                         ],
                        },
                       ],
                       position: (776, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "serviceConfig",
                         position: (777, 11),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "DynamicUser",
                            position: (778, 13),
                           },
                          ],
                         },
                         Variable {
                          identifier: "true",
                          position: (778, 27),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "StateDirectory",
                            position: (779, 13),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (779, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "rule",
                             position: (779, 34),
                            },
                            Raw {
                             content: "stateDir",
                             position: (779, 39),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "Restart",
                            position: (780, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "always",
                            position: (780, 24),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "ExecStart",
                            position: (781, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "thanos",
                           position: (781, 25),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "rule",
                              position: (781, 33),
                             },
                            ],
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (777, 27),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (774, 40),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (773, 7),
                },
               ],
               position: (771, 36),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (787, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (787, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "compact",
                position: (787, 15),
               },
               Raw {
                content: "enable",
                position: (787, 23),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (787, 31),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assertRelativeStateDir",
                  position: (788, 8),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "compact",
                     position: (788, 32),
                    },
                   ],
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "systemd",
                      position: (790, 9),
                     },
                     Raw {
                      content: "services",
                      position: (790, 17),
                     },
                     Raw {
                      content: "thanos-compact",
                      position: (790, 26),
                     },
                    ],
                   },
                   LetIn {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wait",
                         position: (791, 15),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (791, 22),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "compact",
                            position: (791, 26),
                           },
                           Raw {
                            content: "startAt",
                            position: (791, 34),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "null",
                         position: (791, 45),
                        },
                       ],
                       position: (791, 42),
                      },
                     ),
                    ],
                    target: BinaryOperation {
                     operator: Update,
                     operands: [
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "wantedBy",
                            position: (792, 13),
                           },
                          ],
                         },
                         List {
                          elements: [
                           String {
                            parts: [
                             Raw {
                              content: "multi-user.target",
                              position: (792, 27),
                             },
                            ],
                           },
                          ],
                          position: (792, 24),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "after",
                            position: (793, 13),
                           },
                          ],
                         },
                         List {
                          elements: [
                           String {
                            parts: [
                             Raw {
                              content: "network.target",
                              position: (793, 27),
                             },
                            ],
                           },
                          ],
                          position: (793, 24),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "serviceConfig",
                            position: (794, 13),
                           },
                          ],
                         },
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "Type",
                               position: (795, 15),
                              },
                             ],
                            },
                            IfThenElse {
                             predicate: Variable {
                              identifier: "wait",
                              position: (795, 28),
                             },
                             then: String {
                              parts: [
                               Raw {
                                content: "simple",
                                position: (795, 39),
                               },
                              ],
                             },
                             else_: String {
                              parts: [
                               Raw {
                                content: "oneshot",
                                position: (795, 53),
                               },
                              ],
                             },
                             position: (795, 25),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "Restart",
                               position: (796, 15),
                              },
                             ],
                            },
                            IfThenElse {
                             predicate: Variable {
                              identifier: "wait",
                              position: (796, 28),
                             },
                             then: String {
                              parts: [
                               Raw {
                                content: "always",
                                position: (796, 39),
                               },
                              ],
                             },
                             else_: String {
                              parts: [
                               Raw {
                                content: "no",
                                position: (796, 53),
                               },
                              ],
                             },
                             position: (796, 25),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "DynamicUser",
                               position: (797, 15),
                              },
                             ],
                            },
                            Variable {
                             identifier: "true",
                             position: (797, 29),
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "StateDirectory",
                               position: (798, 15),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (798, 32),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "compact",
                                position: (798, 36),
                               },
                               Raw {
                                content: "stateDir",
                                position: (798, 44),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "ExecStart",
                               position: (799, 15),
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "thanos",
                              position: (799, 27),
                             },
                             arguments: [
                              String {
                               parts: [
                                Raw {
                                 content: "compact",
                                 position: (799, 35),
                                },
                               ],
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (794, 29),
                         },
                        ),
                       ],
                       recursive: false,
                       position: (791, 54),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionalAttrs",
                        position: (801, 16),
                       },
                       arguments: [
                        UnaryOperation {
                         operator: Not,
                         operand: Variable {
                          identifier: "wait",
                          position: (801, 32),
                         },
                         position: (801, 31),
                        },
                        Map {
                         bindings: [
                          Inherit(
                           Some(
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (801, 49),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "compact",
                                position: (801, 53),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           [
                            Raw {
                             content: "startAt",
                             position: (801, 62),
                            },
                           ],
                          ),
                         ],
                         recursive: false,
                         position: (801, 38),
                        },
                       ],
                      },
                     ],
                     position: (801, 13),
                    },
                    position: (791, 11),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (789, 7),
                },
               ],
               position: (787, 39),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (805, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (805, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "downsample",
                position: (805, 15),
               },
               Raw {
                content: "enable",
                position: (805, 26),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (805, 34),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assertRelativeStateDir",
                  position: (806, 8),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "downsample",
                     position: (806, 32),
                    },
                   ],
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "systemd",
                      position: (808, 9),
                     },
                     Raw {
                      content: "services",
                      position: (808, 17),
                     },
                     Raw {
                      content: "thanos-downsample",
                      position: (808, 26),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wantedBy",
                         position: (809, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (809, 25),
                          },
                         ],
                        },
                       ],
                       position: (809, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "after",
                         position: (810, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "network.target",
                           position: (810, 25),
                          },
                         ],
                        },
                       ],
                       position: (810, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "serviceConfig",
                         position: (811, 11),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "DynamicUser",
                            position: (812, 13),
                           },
                          ],
                         },
                         Variable {
                          identifier: "true",
                          position: (812, 27),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "StateDirectory",
                            position: (813, 13),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (813, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "downsample",
                             position: (813, 34),
                            },
                            Raw {
                             content: "stateDir",
                             position: (813, 45),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "Restart",
                            position: (814, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "always",
                            position: (814, 24),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "ExecStart",
                            position: (815, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "thanos",
                           position: (815, 25),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "downsample",
                              position: (815, 33),
                             },
                            ],
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (811, 27),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (808, 46),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (807, 7),
                },
               ],
               position: (805, 42),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (821, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (821, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "receive",
                position: (821, 15),
               },
               Raw {
                content: "enable",
                position: (821, 23),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkMerge",
              position: (821, 31),
             },
             arguments: [
              List {
               elements: [
                FunctionApplication {
                 function: Variable {
                  identifier: "assertRelativeStateDir",
                  position: (822, 8),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "receive",
                     position: (822, 32),
                    },
                   ],
                  },
                 ],
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "systemd",
                      position: (824, 9),
                     },
                     Raw {
                      content: "services",
                      position: (824, 17),
                     },
                     Raw {
                      content: "thanos-receive",
                      position: (824, 26),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "wantedBy",
                         position: (825, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "multi-user.target",
                           position: (825, 25),
                          },
                         ],
                        },
                       ],
                       position: (825, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "after",
                         position: (826, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "network.target",
                           position: (826, 25),
                          },
                         ],
                        },
                       ],
                       position: (826, 22),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "serviceConfig",
                         position: (827, 11),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "DynamicUser",
                            position: (828, 13),
                           },
                          ],
                         },
                         Variable {
                          identifier: "true",
                          position: (828, 27),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "StateDirectory",
                            position: (829, 13),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (829, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "receive",
                             position: (829, 34),
                            },
                            Raw {
                             content: "stateDir",
                             position: (829, 42),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "Restart",
                            position: (830, 13),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "always",
                            position: (830, 24),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "ExecStart",
                            position: (831, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "thanos",
                           position: (831, 25),
                          },
                          arguments: [
                           String {
                            parts: [
                             Raw {
                              content: "receive",
                              position: (831, 33),
                             },
                            ],
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (827, 27),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (824, 43),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (823, 7),
                },
               ],
               position: (821, 39),
              },
             ],
            },
           ],
          },
         ],
         position: (714, 20),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (655, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}