---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    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: "grafana",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 17),
        },
        Raw {
         content: "grafana",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "declarativePlugins",
        position: (8, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (8, 24),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "linkFarm",
          position: (8, 29),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "grafana-plugins",
          position: (8, 39),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (8, 57),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "map",
            position: (8, 66),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Function {
          argument: Some(
           "pkg",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (8, 78),
               },
              ],
             },
             PropertyAccess {
              expression: Variable {
               identifier: "pkg",
               position: (8, 85),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "pname",
                 position: (8, 89),
                },
               ],
              },
              default: None,
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "path",
                position: (8, 96),
               },
              ],
             },
             Variable {
              identifier: "pkg",
              position: (8, 103),
             },
            ),
           ],
           recursive: false,
           position: (8, 76),
          },
          position: (8, 71),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (8, 111),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "declarativePlugins",
             position: (8, 115),
            },
           ],
          },
          default: None,
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "useMysql",
        position: (9, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (9, 14),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (9, 18),
          },
          Raw {
           content: "type",
           position: (9, 27),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "mysql",
          position: (9, 36),
         },
        ],
       },
      ],
      position: (9, 32),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "usePostgresql",
        position: (10, 3),
       },
      ],
     },
     BinaryOperation {
      operator: EqualTo,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (10, 19),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "database",
           position: (10, 23),
          },
          Raw {
           content: "type",
           position: (10, 32),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "postgres",
          position: (10, 41),
         },
        ],
       },
      ],
      position: (10, 37),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "envOptions",
        position: (12, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Update,
      operands: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "PATHS_DATA",
             position: (13, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (13, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "dataDir",
              position: (13, 22),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "PATHS_PLUGINS",
             position: (14, 5),
            },
           ],
          },
          IfThenElse {
           predicate: FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (14, 24),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "isNull",
                position: (14, 33),
               },
              ],
             },
             default: None,
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (14, 40),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "declarativePlugins",
                 position: (14, 44),
                },
               ],
              },
              default: None,
             },
            ],
           },
           then: String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (14, 71),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "dataDir",
                  position: (14, 75),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: "/plugins",
              position: (14, 83),
             },
            ],
           },
           else_: Variable {
            identifier: "declarativePlugins",
            position: (14, 98),
           },
           position: (14, 21),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "PATHS_LOGS",
             position: (15, 5),
            },
           ],
          },
          String {
           parts: [
            Expression {
             expression: PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (15, 21),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "dataDir",
                 position: (15, 25),
                },
               ],
              },
              default: None,
             },
            },
            Raw {
             content: "/log",
             position: (15, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_PROTOCOL",
             position: (17, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (17, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "protocol",
              position: (17, 27),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_HTTP_ADDR",
             position: (18, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (18, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "addr",
              position: (18, 28),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_HTTP_PORT",
             position: (19, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (19, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "port",
              position: (19, 28),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_SOCKET",
             position: (20, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (20, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "socket",
              position: (20, 25),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_DOMAIN",
             position: (21, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (21, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "domain",
              position: (21, 25),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_ROOT_URL",
             position: (22, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (22, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "rootUrl",
              position: (22, 27),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_STATIC_ROOT_PATH",
             position: (23, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (23, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "staticRootPath",
              position: (23, 35),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_CERT_FILE",
             position: (24, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (24, 24),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "certFile",
              position: (24, 28),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SERVER_CERT_KEY",
             position: (25, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (25, 23),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "certKey",
              position: (25, 27),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_TYPE",
             position: (27, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (27, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (27, 25),
             },
             Raw {
              content: "type",
              position: (27, 34),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_HOST",
             position: (28, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (28, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (28, 25),
             },
             Raw {
              content: "host",
              position: (28, 34),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_NAME",
             position: (29, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (29, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (29, 25),
             },
             Raw {
              content: "name",
              position: (29, 34),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_USER",
             position: (30, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (30, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (30, 25),
             },
             Raw {
              content: "user",
              position: (30, 34),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_PASSWORD",
             position: (31, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (31, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (31, 29),
             },
             Raw {
              content: "password",
              position: (31, 38),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_PATH",
             position: (32, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (32, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (32, 25),
             },
             Raw {
              content: "path",
              position: (32, 34),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "DATABASE_CONN_MAX_LIFETIME",
             position: (33, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (33, 34),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "database",
              position: (33, 38),
             },
             Raw {
              content: "connMaxLifetime",
              position: (33, 47),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SECURITY_ADMIN_USER",
             position: (35, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (35, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "security",
              position: (35, 31),
             },
             Raw {
              content: "adminUser",
              position: (35, 40),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SECURITY_ADMIN_PASSWORD",
             position: (36, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (36, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "security",
              position: (36, 35),
             },
             Raw {
              content: "adminPassword",
              position: (36, 44),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SECURITY_SECRET_KEY",
             position: (37, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (37, 27),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "security",
              position: (37, 31),
             },
             Raw {
              content: "secretKey",
              position: (37, 40),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "USERS_ALLOW_SIGN_UP",
             position: (39, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (39, 27),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (39, 40),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "users",
                position: (39, 44),
               },
               Raw {
                content: "allowSignUp",
                position: (39, 50),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "USERS_ALLOW_ORG_CREATE",
             position: (40, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (40, 30),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (40, 43),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "users",
                position: (40, 47),
               },
               Raw {
                content: "allowOrgCreate",
                position: (40, 53),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "USERS_AUTO_ASSIGN_ORG",
             position: (41, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (41, 29),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (41, 42),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "users",
                position: (41, 46),
               },
               Raw {
                content: "autoAssignOrg",
                position: (41, 52),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "USERS_AUTO_ASSIGN_ORG_ROLE",
             position: (42, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (42, 34),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (42, 38),
             },
             Raw {
              content: "autoAssignOrgRole",
              position: (42, 44),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_ANONYMOUS_ENABLED",
             position: (44, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (44, 30),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (44, 43),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "auth",
                position: (44, 47),
               },
               Raw {
                content: "anonymous",
                position: (44, 52),
               },
               Raw {
                content: "enable",
                position: (44, 62),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_ANONYMOUS_ORG_NAME",
             position: (45, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (45, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "auth",
              position: (45, 35),
             },
             Raw {
              content: "anonymous",
              position: (45, 40),
             },
             Raw {
              content: "org_name",
              position: (45, 50),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_ANONYMOUS_ORG_ROLE",
             position: (46, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (46, 31),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "auth",
              position: (46, 35),
             },
             Raw {
              content: "anonymous",
              position: (46, 40),
             },
             Raw {
              content: "org_role",
              position: (46, 50),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_GOOGLE_ENABLED",
             position: (47, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (47, 27),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (47, 40),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "auth",
                position: (47, 44),
               },
               Raw {
                content: "google",
                position: (47, 49),
               },
               Raw {
                content: "enable",
                position: (47, 56),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_GOOGLE_ALLOW_SIGN_UP",
             position: (48, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (48, 33),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (48, 46),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "auth",
                position: (48, 50),
               },
               Raw {
                content: "google",
                position: (48, 55),
               },
               Raw {
                content: "allowSignUp",
                position: (48, 62),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "AUTH_GOOGLE_CLIENT_ID",
             position: (49, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (49, 29),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "auth",
              position: (49, 33),
             },
             Raw {
              content: "google",
              position: (49, 38),
             },
             Raw {
              content: "clientId",
              position: (49, 45),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "ANALYTICS_REPORTING_ENABLED",
             position: (51, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (51, 35),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (51, 48),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "analytics",
                position: (51, 52),
               },
               Raw {
                content: "reporting",
                position: (51, 62),
               },
               Raw {
                content: "enable",
                position: (51, 72),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SMTP_ENABLED",
             position: (53, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "boolToString",
            position: (53, 20),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (53, 33),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "smtp",
                position: (53, 37),
               },
               Raw {
                content: "enable",
                position: (53, 42),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SMTP_HOST",
             position: (54, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (54, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (54, 21),
             },
             Raw {
              content: "host",
              position: (54, 26),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SMTP_USER",
             position: (55, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (55, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (55, 21),
             },
             Raw {
              content: "user",
              position: (55, 26),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SMTP_PASSWORD",
             position: (56, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (56, 21),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (56, 25),
             },
             Raw {
              content: "password",
              position: (56, 30),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SMTP_FROM_ADDRESS",
             position: (57, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (57, 25),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "smtp",
              position: (57, 29),
             },
             Raw {
              content: "fromAddress",
              position: (57, 34),
             },
            ],
           },
           default: None,
          },
         ),
        ],
        recursive: false,
        position: (12, 16),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (58, 8),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "extraOptions",
           position: (58, 12),
          },
         ],
        },
        default: None,
       },
      ],
      position: (58, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "datasourceConfiguration",
        position: (60, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "apiVersion",
           position: (61, 5),
          },
         ],
        },
        Int {
         value: 1,
         position: (61, 18),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "datasources",
           position: (62, 5),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (62, 19),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "provision",
            position: (62, 23),
           },
           Raw {
            content: "datasources",
            position: (62, 33),
           },
          ],
         },
         default: None,
        },
       ),
      ],
      recursive: false,
      position: (60, 29),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "datasourceFile",
        position: (65, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (65, 20),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (65, 25),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "datasource.yaml",
          position: (65, 36),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (65, 54),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "toJSON",
            position: (65, 63),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "datasourceConfiguration",
          position: (65, 70),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dashboardConfiguration",
        position: (67, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "apiVersion",
           position: (68, 5),
          },
         ],
        },
        Int {
         value: 1,
         position: (68, 18),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "providers",
           position: (69, 5),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (69, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "provision",
            position: (69, 21),
           },
           Raw {
            content: "dashboards",
            position: (69, 31),
           },
          ],
         },
         default: None,
        },
       ),
      ],
      recursive: false,
      position: (67, 28),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dashboardFile",
        position: (72, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (72, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (72, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "dashboard.yaml",
          position: (72, 35),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (72, 52),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "toJSON",
            position: (72, 61),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "dashboardConfiguration",
          position: (72, 68),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "notifierConfiguration",
        position: (74, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "apiVersion",
           position: (75, 5),
          },
         ],
        },
        Int {
         value: 1,
         position: (75, 18),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "notifiers",
           position: (76, 5),
          },
         ],
        },
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (76, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "provision",
            position: (76, 21),
           },
           Raw {
            content: "notifiers",
            position: (76, 31),
           },
          ],
         },
         default: None,
        },
       ),
      ],
      recursive: false,
      position: (74, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "notifierFile",
        position: (79, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (79, 18),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (79, 23),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "notifier.yaml",
          position: (79, 34),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (79, 50),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "toJSON",
            position: (79, 59),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Variable {
          identifier: "notifierConfiguration",
          position: (79, 66),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "provisionConfDir",
        position: (81, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (81, 23),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "runCommand",
          position: (81, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "grafana-provisioning",
          position: (81, 40),
         },
        ],
       },
       Map {
        bindings: [],
        recursive: false,
        position: (81, 62),
       },
       String {
        parts: [
         Raw {
          content: "mkdir -p $out/{datasources,dashboards,notifiers}\nln -sf ",
          position: (82, 1),
         },
         Expression {
          expression: Variable {
           identifier: "datasourceFile",
           position: (83, 14),
          },
         },
         Raw {
          content: " $out/datasources/datasource.yaml\nln -sf ",
          position: (83, 29),
         },
         Expression {
          expression: Variable {
           identifier: "dashboardFile",
           position: (84, 14),
          },
         },
         Raw {
          content: " $out/dashboards/dashboard.yaml\nln -sf ",
          position: (84, 28),
         },
         Expression {
          expression: Variable {
           identifier: "notifierFile",
           position: (85, 14),
          },
         },
         Raw {
          content: " $out/notifiers/notifier.yaml\n",
          position: (85, 27),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "_filter",
        position: (89, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "filterAttrs",
        position: (89, 16),
       },
       arguments: [
        Function {
         argument: Some(
          "k",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "v",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: BinaryOperation {
           operator: NotEqualTo,
           operands: [
            Variable {
             identifier: "k",
             position: (89, 35),
            },
            String {
             parts: [
              Raw {
               content: "_module",
               position: (89, 41),
              },
             ],
            },
           ],
           position: (89, 37),
          },
          position: (89, 32),
         },
         position: (89, 29),
        },
        Variable {
         identifier: "x",
         position: (89, 51),
        },
       ],
      },
      position: (89, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "grafanaTypes",
        position: (92, 3),
       },
       Raw {
        content: "datasourceConfig",
        position: (92, 16),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "types",
        position: (92, 35),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "submodule",
          position: (92, 41),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "options",
             position: (93, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (94, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (94, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (95, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (95, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (95, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (96, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Name of the datasource. Required.",
                     position: (96, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (94, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (98, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (98, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (99, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (99, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (99, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (100, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Datasource type. Required.",
                     position: (100, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (98, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "access",
                position: (102, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (102, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (103, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (103, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enum",
                       position: (103, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "proxy",
                         position: (103, 29),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "direct",
                         position: (103, 37),
                        },
                       ],
                      },
                     ],
                     position: (103, 27),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (104, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "proxy",
                     position: (104, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (105, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Access mode. proxy or direct (Server or Browser in the UI). Required.",
                     position: (105, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (102, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "orgId",
                position: (107, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (107, 15),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (108, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (108, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "int",
                      position: (108, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (109, 9),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (109, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (110, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Org id. will default to orgId 1 if not specified.",
                     position: (110, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (107, 24),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "url",
                position: (112, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (112, 13),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (113, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (113, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (113, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (114, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Url of the datasource.",
                     position: (114, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (112, 22),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "password",
                position: (116, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (116, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (117, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (117, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (117, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (117, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (117, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (118, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (118, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (119, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database password, if used.",
                     position: (119, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (116, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "user",
                position: (121, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (121, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (122, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (122, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (122, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (122, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (122, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (123, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (123, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (124, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database user, if used.",
                     position: (124, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (121, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "database",
                position: (126, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (126, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (127, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (127, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (127, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (127, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (127, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (128, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (128, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (129, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Database name, if used.",
                     position: (129, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (126, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "basicAuth",
                position: (131, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (131, 19),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (132, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (132, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (132, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (132, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (132, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (133, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (133, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (134, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Enable/disable basic auth.",
                     position: (134, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (131, 28),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "basicAuthUser",
                position: (136, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (136, 23),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (137, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (137, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (137, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (137, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (137, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (138, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (138, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (139, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Basic auth username.",
                     position: (139, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (136, 32),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "basicAuthPassword",
                position: (141, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (141, 27),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (142, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (142, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (142, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (142, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (142, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (143, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (143, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (144, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Basic auth password.",
                     position: (144, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (141, 36),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "withCredentials",
                position: (146, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (146, 25),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (147, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (147, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (147, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (148, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (148, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (149, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Enable/disable with credentials headers.",
                     position: (149, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (146, 34),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "isDefault",
                position: (151, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (151, 19),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (152, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (152, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (152, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (153, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (153, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (154, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Mark as default datasource. Max one per org.",
                     position: (154, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (151, 28),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "jsonData",
                position: (156, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (156, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (157, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (157, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (157, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (157, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrs",
                        position: (157, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (158, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (158, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (159, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Datasource specific configuration.",
                     position: (159, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (156, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "secureJsonData",
                position: (161, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (161, 24),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (162, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (162, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (162, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (162, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrs",
                        position: (162, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (163, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (163, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (164, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Datasource specific secure configuration.",
                     position: (164, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (161, 33),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "version",
                position: (166, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (166, 17),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (167, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (167, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "int",
                      position: (167, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (168, 9),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (168, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (169, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Version.",
                     position: (169, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (166, 26),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "editable",
                position: (171, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (171, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (172, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (172, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (172, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (173, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (173, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (174, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Allow users to edit datasources from the UI.",
                     position: (174, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (171, 27),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (93, 15),
          },
         ),
        ],
        recursive: false,
        position: (92, 51),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "grafanaTypes",
        position: (180, 3),
       },
       Raw {
        content: "dashboardConfig",
        position: (180, 16),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "types",
        position: (180, 34),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "submodule",
          position: (180, 40),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "options",
             position: (181, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (182, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (182, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (183, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (183, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (183, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (184, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "default",
                     position: (184, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (185, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Provider name.",
                     position: (185, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (182, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "orgId",
                position: (187, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (187, 15),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (188, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (188, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "int",
                      position: (188, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (189, 9),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (189, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (190, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Organization ID.",
                     position: (190, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (187, 24),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "folder",
                position: (192, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (192, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (193, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (193, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (193, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (194, 9),
                    },
                   ],
                  },
                  String {
                   parts: [],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (195, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Add dashboards to the specified folder.",
                     position: (195, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (192, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (197, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (197, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (198, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (198, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (198, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (199, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "file",
                     position: (199, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (200, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Dashboard provider type.",
                     position: (200, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (197, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disableDeletion",
                position: (202, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (202, 25),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (203, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (203, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (203, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (204, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (204, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (205, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Disable deletion when JSON file is removed.",
                     position: (205, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (202, 34),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "updateIntervalSeconds",
                position: (207, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (207, 31),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (208, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (208, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "int",
                      position: (208, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (209, 9),
                    },
                   ],
                  },
                  Int {
                   value: 10,
                   position: (209, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (210, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "How often Grafana will scan for changed dashboards.",
                     position: (210, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (207, 40),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "options",
                position: (212, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (213, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkOption",
                  position: (213, 16),
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "type",
                        position: (214, 11),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (214, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "path",
                         position: (214, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "description",
                        position: (215, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "Path grafana will watch for dashboards.",
                        position: (215, 26),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (213, 25),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (212, 17),
             },
            ),
           ],
           recursive: false,
           position: (181, 15),
          },
         ),
        ],
        recursive: false,
        position: (180, 50),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "grafanaTypes",
        position: (221, 3),
       },
       Raw {
        content: "notifierConfig",
        position: (221, 16),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "types",
        position: (221, 33),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "submodule",
          position: (221, 39),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "options",
             position: (222, 5),
            },
           ],
          },
          Map {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (223, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (223, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (224, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (224, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (224, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (225, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "default",
                     position: (225, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (226, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Notifier name.",
                     position: (226, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (223, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "type",
                position: (228, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (228, 14),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (229, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (229, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enum",
                       position: (229, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "dingding",
                         position: (229, 29),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "discord",
                         position: (229, 40),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "email",
                         position: (229, 50),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "googlechat",
                         position: (229, 58),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "hipchat",
                         position: (229, 71),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "kafka",
                         position: (229, 81),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "line",
                         position: (229, 89),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "teams",
                         position: (229, 96),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "opsgenie",
                         position: (229, 104),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "pagerduty",
                         position: (229, 115),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "prometheus-alertmanager",
                         position: (229, 127),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "pushover",
                         position: (229, 153),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "sensu",
                         position: (229, 164),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "sensugo",
                         position: (229, 172),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "slack",
                         position: (229, 182),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "telegram",
                         position: (229, 190),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "threema",
                         position: (229, 201),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "victorops",
                         position: (229, 211),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "webhook",
                         position: (229, 223),
                        },
                       ],
                      },
                     ],
                     position: (229, 27),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (230, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Notifier type.",
                     position: (230, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (228, 23),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "uid",
                position: (232, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (232, 13),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (233, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (233, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (233, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (234, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Unique notifier identifier.",
                     position: (234, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (232, 22),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "org_id",
                position: (236, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (236, 16),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (237, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (237, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "int",
                      position: (237, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (238, 9),
                    },
                   ],
                  },
                  Int {
                   value: 1,
                   position: (238, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (239, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Organization ID.",
                     position: (239, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (236, 25),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "org_name",
                position: (241, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (241, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (242, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (242, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (242, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (243, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Main Org.",
                     position: (243, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (244, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Organization name.",
                     position: (244, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (241, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "is_default",
                position: (246, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (246, 20),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (247, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (247, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (247, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (248, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Is the default notifier.",
                     position: (248, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (249, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (249, 19),
                  },
                 ),
                ],
                recursive: false,
                position: (246, 29),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "send_reminder",
                position: (251, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (251, 23),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (252, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (252, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (252, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (253, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "true",
                   position: (253, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (254, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Should the notifier be sent reminder notifications while alerts continue to fire.",
                     position: (254, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (251, 32),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "frequency",
                position: (256, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (256, 19),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (257, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (257, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "str",
                      position: (257, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (258, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "5m",
                     position: (258, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (259, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "How frequently should the notifier be sent reminders.",
                     position: (259, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (256, 28),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "disable_resolve_message",
                position: (261, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (261, 33),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (262, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (262, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "bool",
                      position: (262, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (263, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "false",
                   position: (263, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (264, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Turn off the message that sends when an alert returns to OK.",
                     position: (264, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (261, 42),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "settings",
                position: (266, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (266, 18),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (267, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (267, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (267, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (267, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrs",
                        position: (267, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (268, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (268, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (269, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Settings for the notifier type.",
                     position: (269, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (266, 27),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "secure_settings",
                position: (271, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkOption",
               position: (271, 25),
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "type",
                     position: (272, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (272, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nullOr",
                       position: (272, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (272, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "attrs",
                        position: (272, 35),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "default",
                     position: (273, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "null",
                   position: (273, 19),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (274, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Secure settings for the notifier type.",
                     position: (274, 24),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (271, 34),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (222, 15),
          },
         ),
        ],
        recursive: false,
        position: (221, 49),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (279, 3),
        },
        Raw {
         content: "services",
         position: (279, 11),
        },
        Raw {
         content: "grafana",
         position: (279, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (280, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (280, 14),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "grafana",
              position: (280, 30),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "protocol",
            position: (282, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (282, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (283, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Which protocol to listen.",
                 position: (283, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (284, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "http",
                 position: (284, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (285, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (285, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "enum",
                   position: (285, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "http",
                     position: (285, 27),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "https",
                     position: (285, 34),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "socket",
                     position: (285, 42),
                    },
                   ],
                  },
                 ],
                 position: (285, 25),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (282, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "addr",
            position: (288, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (288, 12),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (289, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Listening address.",
                 position: (289, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (290, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "127.0.0.1",
                 position: (290, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (291, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (291, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (291, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (288, 21),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "port",
            position: (294, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (294, 12),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (295, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Listening port.",
                 position: (295, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (296, 7),
                },
               ],
              },
              Int {
               value: 3000,
               position: (296, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (297, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (297, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "port",
                  position: (297, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (294, 21),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "socket",
            position: (300, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (300, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (301, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Listening socket.",
                 position: (301, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (302, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/run/grafana/grafana.sock",
                 position: (302, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (303, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (303, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (303, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (300, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "domain",
            position: (306, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (306, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (307, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The public facing domain name used to access grafana from a browser.",
                 position: (307, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (308, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "localhost",
                 position: (308, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (309, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (309, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (309, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (306, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "rootUrl",
            position: (312, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (312, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (313, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Full public facing url.",
                 position: (313, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (314, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "%(protocol)s://%(domain)s:%(http_port)s/",
                 position: (314, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (315, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (315, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (315, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (312, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "certFile",
            position: (318, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (318, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (319, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Cert file for ssl.",
                 position: (319, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (320, 7),
                },
               ],
              },
              String {
               parts: [],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (321, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (321, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (321, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (318, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "certKey",
            position: (324, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (324, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (325, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Cert key for ssl.",
                 position: (325, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (326, 7),
                },
               ],
              },
              String {
               parts: [],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (327, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (327, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (327, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (324, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "staticRootPath",
            position: (330, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (330, 22),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (331, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Root path for static assets.",
                 position: (331, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (332, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (332, 20),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (332, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/share/grafana/public",
                 position: (332, 32),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (333, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (333, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "\"",
                   position: (333, 41),
                  },
                  Raw {
                   content: "$",
                   position: (333, 42),
                  },
                  Raw {
                   content: "{package}/share/grafana/public\"",
                   position: (333, 45),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (334, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (334, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (334, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (330, 31),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "package",
            position: (337, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (337, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (338, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Package to use.",
                 position: (338, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (339, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (339, 17),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "grafana",
                  position: (339, 22),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (340, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (340, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "pkgs.grafana",
                   position: (340, 40),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (341, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (341, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (341, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (337, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "declarativePlugins",
            position: (344, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (344, 26),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (345, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (345, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "nullOr",
                 position: (345, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "listOf",
                   position: (345, 34),
                  },
                  arguments: [
                   Variable {
                    identifier: "path",
                    position: (345, 41),
                   },
                  ],
                 },
                ],
               },
               position: (345, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (346, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (346, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (347, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "If non-null, then a list of packages containing Grafana plugins to install. If set, plugins cannot be manually installed.",
                 position: (347, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (348, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (348, 17),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "with pkgs.grafanaPlugins; [ grafana-piechart-panel ]",
                   position: (348, 36),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "apply",
                 position: (352, 7),
                },
               ],
              },
              Function {
               argument: Some(
                "x",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "isList",
                  position: (352, 21),
                 },
                 arguments: [
                  Variable {
                   identifier: "x",
                   position: (352, 28),
                  },
                 ],
                },
                then: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "lib",
                   position: (352, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "unique",
                     position: (352, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Variable {
                   identifier: "x",
                   position: (352, 46),
                  },
                 ],
                },
                else_: Variable {
                 identifier: "x",
                 position: (352, 53),
                },
                position: (352, 18),
               },
               position: (352, 15),
              },
             ),
            ],
            recursive: false,
            position: (344, 35),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "dataDir",
            position: (355, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (355, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (356, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Data directory.",
                 position: (356, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (357, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/lib/grafana",
                 position: (357, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (358, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (358, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (358, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (355, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "database",
            position: (361, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "type",
               position: (362, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (362, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (363, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database type.",
                    position: (363, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (364, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sqlite3",
                    position: (364, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (365, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (365, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (365, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "mysql",
                        position: (365, 29),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sqlite3",
                        position: (365, 37),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "postgres",
                        position: (365, 47),
                       },
                      ],
                     },
                    ],
                    position: (365, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (362, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "host",
               position: (368, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (368, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (369, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database host.",
                    position: (369, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (370, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "127.0.0.1:3306",
                    position: (370, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (371, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (371, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (371, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (368, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (374, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (374, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (375, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database name.",
                    position: (375, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (376, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "grafana",
                    position: (376, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (377, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (377, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (377, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (374, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (380, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (380, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (381, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database user.",
                    position: (381, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (382, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "root",
                    position: (382, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (383, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (383, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (383, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (380, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "password",
               position: (386, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (386, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (387, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database password.\nThis option is mutual exclusive with the passwordFile option.\n",
                    position: (388, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (391, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (392, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (392, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (392, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (386, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "passwordFile",
               position: (395, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (395, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (396, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "File that containts the database password.\nThis option is mutual exclusive with the password option.\n",
                    position: (397, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (400, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (400, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (401, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (401, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (401, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (401, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (401, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (395, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "path",
               position: (404, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (404, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (405, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Database path.",
                    position: (405, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (406, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (406, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "dataDir",
                        position: (406, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/data/grafana.db",
                    position: (406, 34),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (407, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (407, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"",
                      position: (407, 43),
                     },
                     Raw {
                      content: "$",
                      position: (407, 44),
                     },
                     Raw {
                      content: "{config.",
                      position: (407, 47),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (407, 57),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (407, 61),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/data/grafana.db\"",
                      position: (407, 69),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (408, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (408, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (408, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (404, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "connMaxLifetime",
               position: (411, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (411, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (412, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Sets the maximum amount of time (in seconds) a connection may be reused.\nFor MySQL this setting should be shorter than the `wait_timeout' variable.\n",
                    position: (413, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (416, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "unlimited",
                    position: (416, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (417, 9),
                   },
                  ],
                 },
                 Int {
                  value: 14400,
                  position: (417, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (418, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (418, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "either",
                      position: (418, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (418, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "int",
                       position: (418, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (418, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "enum",
                        position: (418, 46),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "unlimited",
                          position: (418, 54),
                         },
                        ],
                       },
                      ],
                      position: (418, 51),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (411, 34),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (361, 16),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "provision",
            position: (422, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (423, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (423, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "provision",
                 position: (423, 32),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "datasources",
               position: (424, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (424, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (425, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Grafana datasources configuration.",
                    position: (425, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (426, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (426, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (427, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (427, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (427, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "grafanaTypes",
                     position: (427, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "datasourceConfig",
                       position: (427, 42),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (428, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (428, 20),
                   },
                   arguments: [
                    Variable {
                     identifier: "_filter",
                     position: (428, 24),
                    },
                    Variable {
                     identifier: "x",
                     position: (428, 32),
                    },
                   ],
                  },
                  position: (428, 17),
                 },
                ),
               ],
               recursive: false,
               position: (424, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dashboards",
               position: (430, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (430, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (431, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Grafana dashboard configuration.",
                    position: (431, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (432, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (432, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (433, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (433, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (433, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "grafanaTypes",
                     position: (433, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "dashboardConfig",
                       position: (433, 42),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (434, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (434, 20),
                   },
                   arguments: [
                    Variable {
                     identifier: "_filter",
                     position: (434, 24),
                    },
                    Variable {
                     identifier: "x",
                     position: (434, 32),
                    },
                   ],
                  },
                  position: (434, 17),
                 },
                ),
               ],
               recursive: false,
               position: (430, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "notifiers",
               position: (436, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (436, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (437, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Grafana notifier configuration.",
                    position: (437, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (438, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (438, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (439, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (439, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (439, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "grafanaTypes",
                     position: (439, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "notifierConfig",
                       position: (439, 42),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (440, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "map",
                    position: (440, 20),
                   },
                   arguments: [
                    Variable {
                     identifier: "_filter",
                     position: (440, 24),
                    },
                    Variable {
                     identifier: "x",
                     position: (440, 32),
                    },
                   ],
                  },
                  position: (440, 17),
                 },
                ),
               ],
               recursive: false,
               position: (436, 28),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (422, 17),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (444, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "adminUser",
               position: (445, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (445, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (446, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Default admin username.",
                    position: (446, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (447, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "admin",
                    position: (447, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (448, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (448, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (448, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (445, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "adminPassword",
               position: (451, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (451, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (452, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Default admin password.\nThis option is mutual exclusive with the adminPasswordFile option.\n",
                    position: (453, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (456, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "admin",
                    position: (456, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (457, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (457, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (457, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (451, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "adminPasswordFile",
               position: (460, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (460, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (461, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Default admin password.\nThis option is mutual exclusive with the <literal>adminPassword</literal> option.\n",
                    position: (462, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (465, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (465, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (466, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (466, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (466, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (466, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (466, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (460, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secretKey",
               position: (469, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (469, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (470, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Secret key used for signing.",
                    position: (470, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (471, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "SW2YcwTIb9zpOOhoPsMm",
                    position: (471, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (472, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (472, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (472, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (469, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "secretKeyFile",
               position: (475, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (475, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (476, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Secret key used for signing.",
                    position: (476, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (477, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (477, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (478, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (478, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (478, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (478, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (478, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (475, 32),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (444, 16),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "smtp",
            position: (482, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (483, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (483, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "smtp",
                 position: (483, 32),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "host",
               position: (484, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (484, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (485, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Host to connect to.",
                    position: (485, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (486, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "localhost:25",
                    position: (486, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (487, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (487, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (487, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (484, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "user",
               position: (489, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (489, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (490, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "User used for authentication.",
                    position: (490, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (491, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (492, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (492, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (492, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (489, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "password",
               position: (494, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (494, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (495, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Password used for authentication.\nThis option is mutual exclusive with the passwordFile option.\n",
                    position: (496, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (499, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (500, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (500, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (500, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (494, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "passwordFile",
               position: (502, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (502, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (503, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Password used for authentication.\nThis option is mutual exclusive with the password option.\n",
                    position: (504, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (507, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (507, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (508, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (508, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (508, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (508, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (508, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (502, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "fromAddress",
               position: (510, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (510, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (511, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Email address used for sending.",
                    position: (511, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (512, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "admin@grafana.localhost",
                    position: (512, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (513, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (513, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (513, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (510, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (482, 12),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (517, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "allowSignUp",
               position: (518, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (518, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (519, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Disable user signup / registration.",
                    position: (519, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (520, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (520, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (521, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (521, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (521, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (518, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "allowOrgCreate",
               position: (524, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (524, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (525, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether user is allowed to create organizations.",
                    position: (525, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (526, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (526, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (527, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (527, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (527, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (524, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "autoAssignOrg",
               position: (530, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (530, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (531, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to automatically assign new users to default org.",
                    position: (531, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (532, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (532, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (533, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (533, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (533, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (530, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "autoAssignOrgRole",
               position: (536, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (536, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (537, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Default role new users will be auto assigned.",
                    position: (537, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (538, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Viewer",
                    position: (538, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (539, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (539, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (539, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "Viewer",
                        position: (539, 29),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "Editor",
                        position: (539, 38),
                       },
                      ],
                     },
                    ],
                    position: (539, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (536, 36),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (517, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "auth",
            position: (543, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "anonymous",
               position: (544, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (545, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (545, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (546, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to allow anonymous access.",
                       position: (546, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (547, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (547, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (548, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (548, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (548, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (545, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "org_name",
                  position: (550, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (550, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (551, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Which organization to allow anonymous access to.",
                       position: (551, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (552, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Main Org.",
                       position: (552, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (553, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (553, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (553, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (550, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "org_role",
                  position: (555, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (555, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (556, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Which role anonymous users have in the organization.",
                       position: (556, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (557, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Viewer",
                       position: (557, 22),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (558, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (558, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (558, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (555, 29),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (544, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "google",
               position: (561, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "enable",
                  position: (562, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (562, 18),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (563, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to allow Google OAuth2.",
                       position: (563, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (564, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (564, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (565, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (565, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (565, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (562, 27),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "allowSignUp",
                  position: (567, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (567, 23),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (568, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Whether to allow sign up with Google OAuth2.",
                       position: (568, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (569, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (569, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (570, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (570, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "bool",
                        position: (570, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (567, 32),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "clientId",
                  position: (572, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (572, 20),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (573, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Google OAuth2 client ID.",
                       position: (573, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (574, 11),
                      },
                     ],
                    },
                    String {
                     parts: [],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (575, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (575, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "str",
                        position: (575, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (572, 29),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "clientSecretFile",
                  position: (577, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (577, 28),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (578, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Google OAuth2 client secret.",
                       position: (578, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (579, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (579, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (580, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (580, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "nullOr",
                         position: (580, 24),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (580, 31),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "path",
                          position: (580, 37),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (577, 37),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (561, 16),
            },
           ),
          ],
          recursive: false,
          position: (543, 12),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "analytics",
            position: (585, 5),
           },
           Raw {
            content: "reporting",
            position: (585, 15),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (586, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (586, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (587, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to allow anonymous usage reporting to stats.grafana.net.",
                    position: (587, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (588, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (588, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (589, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (589, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (589, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (586, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (585, 27),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "extraOptions",
            position: (593, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (593, 20),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (594, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Extra configuration options passed as env variables as specified in\n<link xlink:href=\"http://docs.grafana.org/installation/configuration/\">documentation</link>,\nbut without GF_ prefix\n",
                 position: (595, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (599, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (599, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (600, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (600, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (600, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "either",
                   position: (600, 35),
                  },
                  arguments: [
                   Variable {
                    identifier: "str",
                    position: (600, 42),
                   },
                   Variable {
                    identifier: "path",
                    position: (600, 46),
                   },
                  ],
                 },
                ],
               },
               position: (600, 14),
              },
             ),
            ],
            recursive: false,
            position: (593, 29),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (279, 30),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (604, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (604, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (604, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (604, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "warnings",
              position: (605, 5),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "flatten",
             position: (605, 16),
            },
            arguments: [
             List {
              elements: [
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (606, 8),
                },
                arguments: [
                 BinaryOperation {
                  operator: LogicalOr,
                  operands: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (607, 9),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (607, 13),
                        },
                        Raw {
                         content: "password",
                         position: (607, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "opt",
                       position: (607, 34),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (607, 38),
                        },
                        Raw {
                         content: "password",
                         position: (607, 47),
                        },
                        Raw {
                         content: "default",
                         position: (607, 56),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (607, 31),
                   },
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (608, 9),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (608, 13),
                        },
                        Raw {
                         content: "adminPassword",
                         position: (608, 22),
                        },
                       ],
                      },
                      default: None,
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "opt",
                       position: (608, 39),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (608, 43),
                        },
                        Raw {
                         content: "adminPassword",
                         position: (608, 52),
                        },
                        Raw {
                         content: "default",
                         position: (608, 66),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (608, 36),
                   },
                  ],
                  position: (607, 64),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Grafana passwords will be stored as plaintext in the Nix store!",
                    position: (609, 10),
                   },
                  ],
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (610, 8),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "any",
                   position: (611, 9),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "x",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      BinaryOperation {
                       operator: LogicalOr,
                       operands: [
                        BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "x",
                            position: (611, 17),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "password",
                              position: (611, 19),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (611, 31),
                          },
                         ],
                         position: (611, 28),
                        },
                        BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "x",
                            position: (611, 39),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "basicAuthPassword",
                              position: (611, 41),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (611, 62),
                          },
                         ],
                         position: (611, 59),
                        },
                       ],
                       position: (611, 36),
                      },
                      BinaryOperation {
                       operator: NotEqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "x",
                          position: (611, 70),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "secureJsonData",
                            position: (611, 72),
                           },
                          ],
                         },
                         default: None,
                        },
                        Variable {
                         identifier: "null",
                         position: (611, 90),
                        },
                       ],
                       position: (611, 87),
                      },
                     ],
                     position: (611, 67),
                    },
                    position: (611, 14),
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (611, 96),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "provision",
                       position: (611, 100),
                      },
                      Raw {
                       content: "datasources",
                       position: (611, 110),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Datasource passwords will be stored as plaintext in the Nix store!",
                    position: (612, 10),
                   },
                  ],
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (613, 8),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "any",
                   position: (614, 9),
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "x",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: NotEqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "x",
                        position: (614, 17),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "secure_settings",
                          position: (614, 19),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "null",
                       position: (614, 38),
                      },
                     ],
                     position: (614, 35),
                    },
                    position: (614, 14),
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (614, 44),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "provision",
                       position: (614, 48),
                      },
                      Raw {
                       content: "notifiers",
                       position: (614, 58),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Notifier secure settings will be stored as plaintext in the Nix store!",
                    position: (615, 10),
                   },
                  ],
                 },
                ],
               },
              ],
              position: (605, 24),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (618, 5),
             },
             Raw {
              content: "systemPackages",
              position: (618, 17),
             },
            ],
           },
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (618, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "package",
                 position: (618, 40),
                },
               ],
              },
              default: None,
             },
            ],
            position: (618, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (620, 5),
             },
            ],
           },
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (622, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (622, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (622, 25),
                       },
                       Raw {
                        content: "password",
                        position: (622, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (622, 46),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (622, 50),
                       },
                       Raw {
                        content: "password",
                        position: (622, 59),
                       },
                       Raw {
                        content: "default",
                        position: (622, 68),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (622, 43),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (622, 79),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "database",
                        position: (622, 83),
                       },
                       Raw {
                        content: "passwordFile",
                        position: (622, 92),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (622, 108),
                    },
                   ],
                   position: (622, 105),
                  },
                 ],
                 position: (622, 76),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (623, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Cannot set both password and passwordFile",
                   position: (623, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (621, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (626, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (626, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (626, 25),
                       },
                       Raw {
                        content: "adminPassword",
                        position: (626, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (626, 51),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (626, 55),
                       },
                       Raw {
                        content: "adminPassword",
                        position: (626, 64),
                       },
                       Raw {
                        content: "default",
                        position: (626, 78),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (626, 48),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (626, 89),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (626, 93),
                       },
                       Raw {
                        content: "adminPasswordFile",
                        position: (626, 102),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (626, 123),
                    },
                   ],
                   position: (626, 120),
                  },
                 ],
                 position: (626, 86),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (627, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Cannot set both adminPassword and adminPasswordFile",
                   position: (627, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (625, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (630, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (630, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (630, 25),
                       },
                       Raw {
                        content: "secretKey",
                        position: (630, 34),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (630, 47),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (630, 51),
                       },
                       Raw {
                        content: "secretKey",
                        position: (630, 60),
                       },
                       Raw {
                        content: "default",
                        position: (630, 70),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (630, 44),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (630, 81),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (630, 85),
                       },
                       Raw {
                        content: "secretKeyFile",
                        position: (630, 94),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (630, 111),
                    },
                   ],
                   position: (630, 108),
                  },
                 ],
                 position: (630, 78),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (631, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Cannot set both secretKey and secretKeyFile",
                   position: (631, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (629, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (634, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (634, 21),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "smtp",
                        position: (634, 25),
                       },
                       Raw {
                        content: "password",
                        position: (634, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "opt",
                      position: (634, 42),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "smtp",
                        position: (634, 46),
                       },
                       Raw {
                        content: "password",
                        position: (634, 51),
                       },
                       Raw {
                        content: "default",
                        position: (634, 60),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (634, 39),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (634, 71),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "smtp",
                        position: (634, 75),
                       },
                       Raw {
                        content: "passwordFile",
                        position: (634, 80),
                       },
                      ],
                     },
                     default: None,
                    },
                    Variable {
                     identifier: "null",
                     position: (634, 96),
                    },
                   ],
                   position: (634, 93),
                  },
                 ],
                 position: (634, 68),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (635, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Cannot set both password and passwordFile",
                   position: (635, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (633, 7),
             },
            ],
            position: (620, 18),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (639, 5),
             },
             Raw {
              content: "services",
              position: (639, 13),
             },
             Raw {
              content: "grafana",
              position: (639, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (640, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Grafana Service Daemon",
                 position: (640, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "wantedBy",
                 position: (641, 7),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "multi-user.target",
                   position: (641, 20),
                  },
                 ],
                },
               ],
               position: (641, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "after",
                 position: (642, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "networking.target",
                     position: (642, 17),
                    },
                   ],
                  },
                 ],
                 position: (642, 15),
                },
                BinaryOperation {
                 operator: Concatenation,
                 operands: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (642, 40),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "optional",
                       position: (642, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "usePostgresql",
                     position: (642, 53),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "postgresql.service",
                       position: (642, 68),
                      },
                     ],
                    },
                   ],
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (642, 91),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "optional",
                       position: (642, 95),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "useMysql",
                     position: (642, 104),
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mysql.service",
                       position: (642, 114),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (642, 88),
                },
               ],
               position: (642, 37),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (643, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "QT_QPA_PLATFORM",
                      position: (644, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "offscreen",
                      position: (644, 28),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (643, 21),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrs'",
                  position: (645, 12),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "n",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: Function {
                    argument: Some(
                     "v",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: FunctionApplication {
                     function: Variable {
                      identifier: "nameValuePair",
                      position: (645, 29),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "GF_",
                         position: (645, 44),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "n",
                          position: (645, 49),
                         },
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "toString",
                        position: (645, 54),
                       },
                       arguments: [
                        Variable {
                         identifier: "v",
                         position: (645, 63),
                        },
                       ],
                      },
                     ],
                    },
                    position: (645, 26),
                   },
                   position: (645, 23),
                  },
                  Variable {
                   identifier: "envOptions",
                   position: (645, 67),
                  },
                 ],
                },
               ],
               position: (645, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "script",
                 position: (646, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "set -o errexit -o pipefail -o nounset -o errtrace\nshopt -s inherit_errexit\n\n",
                 position: (647, 1),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (650, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (650, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "auth",
                         position: (650, 31),
                        },
                        Raw {
                         content: "google",
                         position: (650, 36),
                        },
                        Raw {
                         content: "clientSecretFile",
                         position: (650, 43),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (650, 63),
                     },
                    ],
                    position: (650, 60),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GF_AUTH_GOOGLE_CLIENT_SECRET=\"$(<",
                      position: (651, 1),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (651, 46),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (651, 61),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "auth",
                            position: (651, 65),
                           },
                           Raw {
                            content: "google",
                            position: (651, 70),
                           },
                           Raw {
                            content: "clientSecretFile",
                            position: (651, 77),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: ")\"\nexport GF_AUTH_GOOGLE_CLIENT_SECRET\n",
                      position: (651, 94),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (653, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (654, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (654, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "database",
                         position: (654, 31),
                        },
                        Raw {
                         content: "passwordFile",
                         position: (654, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (654, 56),
                     },
                    ],
                    position: (654, 53),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GF_DATABASE_PASSWORD=\"$(<",
                      position: (655, 1),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (655, 38),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (655, 53),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "database",
                            position: (655, 57),
                           },
                           Raw {
                            content: "passwordFile",
                            position: (655, 66),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: ")\"\nexport GF_DATABASE_PASSWORD\n",
                      position: (655, 79),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (657, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (658, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (658, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (658, 31),
                        },
                        Raw {
                         content: "adminPasswordFile",
                         position: (658, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (658, 61),
                     },
                    ],
                    position: (658, 58),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GF_SECURITY_ADMIN_PASSWORD=\"$(<",
                      position: (659, 1),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (659, 44),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (659, 59),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "security",
                            position: (659, 63),
                           },
                           Raw {
                            content: "adminPasswordFile",
                            position: (659, 72),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: ")\"\nexport GF_SECURITY_ADMIN_PASSWORD\n",
                      position: (659, 90),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (661, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (662, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (662, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (662, 31),
                        },
                        Raw {
                         content: "secretKeyFile",
                         position: (662, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (662, 57),
                     },
                    ],
                    position: (662, 54),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GF_SECURITY_SECRET_KEY=\"$(<",
                      position: (663, 1),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (663, 40),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (663, 55),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "security",
                            position: (663, 59),
                           },
                           Raw {
                            content: "secretKeyFile",
                            position: (663, 68),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: ")\"\nexport GF_SECURITY_SECRET_KEY\n",
                      position: (663, 82),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (665, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (666, 11),
                  },
                  arguments: [
                   BinaryOperation {
                    operator: NotEqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (666, 27),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp",
                         position: (666, 31),
                        },
                        Raw {
                         content: "passwordFile",
                         position: (666, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (666, 52),
                     },
                    ],
                    position: (666, 49),
                   },
                   String {
                    parts: [
                     Raw {
                      content: "GF_SMTP_PASSWORD=\"$(<",
                      position: (667, 1),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "escapeShellArg",
                        position: (667, 34),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (667, 49),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "smtp",
                            position: (667, 53),
                           },
                           Raw {
                            content: "passwordFile",
                            position: (667, 58),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     },
                     Raw {
                      content: ")\"\nexport GF_SMTP_PASSWORD\n",
                      position: (667, 71),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n",
                 position: (669, 12),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "optionalString",
                   position: (670, 11),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (670, 26),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "provision",
                       position: (670, 30),
                      },
                      Raw {
                       content: "enable",
                       position: (670, 40),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "export GF_PATHS_PROVISIONING=",
                      position: (671, 1),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "provisionConfDir",
                       position: (671, 42),
                      },
                     },
                     Raw {
                      content: ";\n",
                      position: (671, 59),
                     },
                    ],
                   },
                  ],
                 },
                },
                Raw {
                 content: "\nexec ",
                 position: (672, 12),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (673, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (673, 20),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/bin/grafana-server -homepath ",
                 position: (673, 28),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (673, 60),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (673, 64),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\n",
                 position: (673, 72),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (675, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "WorkingDirectory",
                    position: (676, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (676, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (676, 32),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "User",
                    position: (677, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "grafana",
                    position: (677, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectory",
                    position: (678, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "grafana",
                    position: (678, 29),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RuntimeDirectoryMode",
                    position: (679, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0755",
                    position: (679, 33),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "AmbientCapabilities",
                    position: (681, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (681, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mkIf",
                      position: (681, 35),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   BinaryOperation {
                    operator: LessThan,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (681, 41),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "port",
                         position: (681, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                     Int {
                      value: 1024,
                      position: (681, 52),
                     },
                    ],
                    position: (681, 50),
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "CAP_NET_BIND_SERVICE",
                        position: (681, 61),
                       },
                      ],
                     },
                    ],
                    position: (681, 58),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "CapabilityBoundingSet",
                    position: (682, 9),
                   },
                  ],
                 },
                 IfThenElse {
                  predicate: BinaryOperation {
                   operator: LessThan,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (682, 37),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "port",
                        position: (682, 41),
                       },
                      ],
                     },
                     default: None,
                    },
                    Int {
                     value: 1024,
                     position: (682, 48),
                    },
                   ],
                   position: (682, 46),
                  },
                  then: List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "CAP_NET_BIND_SERVICE",
                       position: (682, 62),
                      },
                     ],
                    },
                   ],
                   position: (682, 59),
                  },
                  else_: List {
                   elements: [
                    String {
                     parts: [],
                    },
                   ],
                   position: (682, 91),
                  },
                  position: (682, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "DeviceAllow",
                    position: (683, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [],
                   },
                  ],
                  position: (683, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LockPersonality",
                    position: (684, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (684, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "NoNewPrivileges",
                    position: (685, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (685, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateDevices",
                    position: (686, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (686, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "PrivateTmp",
                    position: (687, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (687, 22),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectClock",
                    position: (688, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (688, 24),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectControlGroups",
                    position: (689, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (689, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHome",
                    position: (690, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (690, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectHostname",
                    position: (691, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (691, 27),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelLogs",
                    position: (692, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (692, 29),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelModules",
                    position: (693, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (693, 32),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectKernelTunables",
                    position: (694, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (694, 33),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectProc",
                    position: (695, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "invisible",
                    position: (695, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "ProtectSystem",
                    position: (696, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "full",
                    position: (696, 26),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RemoveIPC",
                    position: (697, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (697, 21),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictAddressFamilies",
                    position: (698, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET",
                      position: (698, 38),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_INET6",
                      position: (698, 48),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "AF_UNIX",
                      position: (698, 59),
                     },
                    ],
                   },
                  ],
                  position: (698, 35),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictNamespaces",
                    position: (699, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (699, 30),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictRealtime",
                    position: (700, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (700, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "RestrictSUIDSGID",
                    position: (701, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (701, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallArchitectures",
                    position: (702, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "native",
                    position: (702, 36),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "SystemCallFilter",
                    position: (705, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "@system-service",
                      position: (705, 31),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "~@privileged",
                      position: (705, 49),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "~@resources",
                      position: (705, 64),
                     },
                    ],
                   },
                  ],
                  position: (705, 28),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "UMask",
                    position: (706, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "0027",
                    position: (706, 18),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (675, 23),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "preStart",
                 position: (708, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "ln -fs ",
                 position: (709, 1),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (709, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (709, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/share/grafana/conf ",
                 position: (709, 30),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (709, 52),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (709, 56),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\nln -fs ",
                 position: (709, 64),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (710, 18),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (710, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/share/grafana/tools ",
                 position: (710, 30),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (710, 53),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "dataDir",
                     position: (710, 57),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "\n",
                 position: (710, 65),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (639, 32),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (714, 5),
             },
             Raw {
              content: "users",
              position: (714, 11),
             },
             Raw {
              content: "grafana",
              position: (714, 17),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (715, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (715, 13),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (715, 20),
                 },
                 Raw {
                  content: "uids",
                  position: (715, 24),
                 },
                 Raw {
                  content: "grafana",
                  position: (715, 29),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (716, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Grafana user",
                 position: (716, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (717, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (717, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "dataDir",
                  position: (717, 18),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "createHome",
                 position: (718, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (718, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (719, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "grafana",
                 position: (719, 16),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (714, 27),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (721, 5),
             },
             Raw {
              content: "groups",
              position: (721, 11),
             },
             Raw {
              content: "grafana",
              position: (721, 18),
             },
            ],
           },
           Map {
            bindings: [],
            recursive: false,
            position: (721, 28),
           },
          ),
         ],
         recursive: false,
         position: (604, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (278, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}