---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "version",
        position: (6, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "1.7.1",
        position: (6, 14),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 16),
        },
        Raw {
         content: "kubernetes",
         position: (7, 25),
        },
        Raw {
         content: "addons",
         position: (7, 36),
        },
        Raw {
         content: "dns",
         position: (7, 43),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "ports",
        position: (8, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "dns",
           position: (9, 5),
          },
         ],
        },
        Int {
         value: 10053,
         position: (9, 11),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "health",
           position: (10, 5),
          },
         ],
        },
        Int {
         value: 10054,
         position: (10, 14),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "metrics",
           position: (11, 5),
          },
         ],
        },
        Int {
         value: 10055,
         position: (11, 15),
        },
       ),
      ],
      recursive: false,
      position: (8, 11),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (14, 3),
        },
        Raw {
         content: "services",
         position: (14, 11),
        },
        Raw {
         content: "kubernetes",
         position: (14, 20),
        },
        Raw {
         content: "addons",
         position: (14, 31),
        },
        Raw {
         content: "dns",
         position: (14, 38),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (15, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (15, 14),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "kubernetes dns addon",
              position: (15, 30),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "clusterIp",
            position: (17, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (17, 17),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (18, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Dns addon clusterIP",
                 position: (18, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (21, 7),
                },
               ],
              },
              BinaryOperation {
               operator: Addition,
               operands: [
                FunctionApplication {
                 function: Variable {
                  identifier: "concatStringsSep",
                  position: (22, 9),
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: ".",
                     position: (22, 27),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "take",
                    position: (23, 11),
                   },
                   arguments: [
                    Int {
                     value: 3,
                     position: (23, 16),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "splitString",
                      position: (23, 19),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: ".",
                         position: (23, 32),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (23, 35),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "services",
                          position: (23, 42),
                         },
                         Raw {
                          content: "kubernetes",
                          position: (23, 51),
                         },
                         Raw {
                          content: "apiserver",
                          position: (23, 62),
                         },
                         Raw {
                          content: "serviceClusterIpRange",
                          position: (23, 72),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: ".254",
                   position: (25, 12),
                  },
                 ],
                },
               ],
               position: (25, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (26, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalDocBook",
                position: (26, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "The <literal>x.y.z.254</literal> IP of\n<literal>config.",
                   position: (27, 1),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "options",
                     position: (28, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "services",
                       position: (28, 35),
                      },
                      Raw {
                       content: "kubernetes",
                       position: (28, 44),
                      },
                      Raw {
                       content: "apiserver",
                       position: (28, 55),
                      },
                      Raw {
                       content: "serviceClusterIpRange",
                       position: (28, 65),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "</literal>.\n",
                   position: (28, 87),
                  },
                 ],
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (30, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (30, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (30, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (17, 26),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "clusterDomain",
            position: (33, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (33, 21),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (34, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Dns cluster domain",
                 position: (34, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (35, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "cluster.local",
                 position: (35, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (36, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (36, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (36, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (33, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "replicas",
            position: (39, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (39, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (40, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Number of DNS pod replicas to deploy in the cluster.",
                 position: (40, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (41, 7),
                },
               ],
              },
              Int {
               value: 2,
               position: (41, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (42, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (42, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "int",
                  position: (42, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (39, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "reconcileMode",
            position: (45, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (45, 21),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (46, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Controls the addon manager reconciliation mode for the DNS addon.\n\nSetting reconcile mode to EnsureExists makes it possible to tailor DNS behavior by editing the coredns ConfigMap.\n\nSee: <link xlink:href=\"https://github.com/kubernetes/kubernetes/blob/master/cluster/addons/addon-manager/README.md\"/>.\n",
                 position: (47, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (53, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Reconcile",
                 position: (53, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (54, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (54, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "enum",
                   position: (54, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "Reconcile",
                     position: (54, 28),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "EnsureExists",
                     position: (54, 40),
                    },
                   ],
                  },
                 ],
                 position: (54, 25),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (45, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "coredns",
            position: (57, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (57, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (58, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Docker image to seed for the CoreDNS container.",
                 position: (58, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (59, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (59, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "attrs",
                  position: (59, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (60, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "imageName",
                    position: (61, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "coredns/coredns",
                    position: (61, 22),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "imageDigest",
                    position: (62, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sha256:4a6e0769130686518325b21b0c1d0688b54e7c79244d48e1b15634e98e40c6ef",
                    position: (62, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "finalImageTag",
                    position: (63, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "version",
                  position: (63, 25),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "sha256",
                    position: (64, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "02r440xcdsgi137k5lmmvp0z5w5fmk8g9mysq5pnysq1wl8sj6mw",
                    position: (64, 19),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (60, 17),
              },
             ),
            ],
            recursive: false,
            position: (57, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "corefile",
            position: (68, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (68, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (69, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Custom coredns corefile configuration.\n\nSee: <link xlink:href=\"https://coredns.io/manual/toc/#configuration\"/>.\n",
                 position: (70, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (74, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (74, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (74, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (75, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "        .:",
                 position: (76, 1),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (76, 13),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "ports",
                     position: (76, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "dns",
                       position: (76, 28),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Raw {
                 content: " {\n  errors\n  health :",
                 position: (76, 32),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (78, 21),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "ports",
                     position: (78, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "health",
                       position: (78, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n  kubernetes ",
                 position: (78, 43),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (79, 24),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "clusterDomain",
                     position: (79, 28),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: " in-addr.arpa ip6.arpa {\n    pods insecure\n    fallthrough in-addr.arpa ip6.arpa\n  }\n  prometheus :",
                 position: (79, 42),
                },
                Expression {
                 expression: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (83, 25),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "ports",
                     position: (83, 34),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "metrics",
                       position: (83, 40),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Raw {
                 content: "\n  forward . /etc/resolv.conf\n  cache 30\n  loop\n  reload\n  loadbalance\n}",
                 position: (83, 48),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (90, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "literalExpression",
                position: (90, 21),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "",
                   position: (91, 1),
                  },
                  Raw {
                   content: "''",
                   position: (91, 9),
                  },
                  Raw {
                   content: "\n  .:",
                   position: (91, 12),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (92, 15),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "ports",
                       position: (92, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dns",
                         position: (92, 30),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: " {\n    errors\n    health :",
                   position: (92, 34),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (94, 23),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "ports",
                       position: (94, 32),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "health",
                         position: (94, 38),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\n    kubernetes ",
                   position: (94, 45),
                  },
                  Raw {
                   content: "$",
                   position: (95, 24),
                  },
                  Raw {
                   content: "{config.services.kubernetes.addons.dns.clusterDomain} in-addr.arpa ip6.arpa {\n      pods insecure\n      fallthrough in-addr.arpa ip6.arpa\n    }\n    prometheus :",
                   position: (95, 27),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (99, 27),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "ports",
                       position: (99, 36),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "metrics",
                         position: (99, 42),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                  Raw {
                   content: "\n    forward . /etc/resolv.conf\n    cache 30\n    loop\n    reload\n    loadbalance\n  }\n",
                   position: (99, 50),
                  },
                  Raw {
                   content: "''",
                   position: (106, 9),
                  },
                  Raw {
                   content: "\n",
                   position: (106, 12),
                  },
                 ],
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (68, 25),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (14, 44),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (111, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (111, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (111, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (111, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (112, 5),
             },
             Raw {
              content: "kubernetes",
              position: (112, 14),
             },
             Raw {
              content: "kubelet",
              position: (112, 25),
             },
             Raw {
              content: "seedDockerImages",
              position: (112, 33),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "singleton",
             position: (113, 7),
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "pkgs",
                position: (113, 18),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "dockerTools",
                  position: (113, 23),
                 },
                 Raw {
                  content: "pullImage",
                  position: (113, 35),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (113, 45),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "coredns",
                   position: (113, 49),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (115, 5),
             },
             Raw {
              content: "kubernetes",
              position: (115, 14),
             },
             Raw {
              content: "addonManager",
              position: (115, 25),
             },
             Raw {
              content: "bootstrapAddons",
              position: (115, 38),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-cr",
                 position: (116, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (117, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rbac.authorization.k8s.io/v1",
                    position: (117, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (118, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ClusterRole",
                    position: (118, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (119, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (120, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (121, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Reconcile",
                          position: (121, 50),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (122, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (122, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (123, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (123, 48),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/bootstrapping",
                             position: (124, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "rbac-defaults",
                          position: (124, 46),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (120, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (126, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "system:coredns",
                       position: (126, 19),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (119, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "rules",
                    position: (128, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "apiGroups",
                         position: (130, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [],
                        },
                       ],
                       position: (130, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "resources",
                         position: (131, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "endpoints",
                           position: (131, 28),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "services",
                           position: (131, 40),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "pods",
                           position: (131, 51),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "namespaces",
                           position: (131, 58),
                          },
                         ],
                        },
                       ],
                       position: (131, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "verbs",
                         position: (132, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "list",
                           position: (132, 24),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "watch",
                           position: (132, 31),
                          },
                         ],
                        },
                       ],
                       position: (132, 21),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (129, 11),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "apiGroups",
                         position: (135, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [],
                        },
                       ],
                       position: (135, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "resources",
                         position: (136, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "nodes",
                           position: (136, 28),
                          },
                         ],
                        },
                       ],
                       position: (136, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "verbs",
                         position: (137, 13),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "get",
                           position: (137, 24),
                          },
                         ],
                        },
                       ],
                       position: (137, 21),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (134, 11),
                   },
                  ],
                  position: (128, 17),
                 },
                ),
               ],
               recursive: false,
               position: (116, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-crb",
                 position: (142, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (143, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "rbac.authorization.k8s.io/v1",
                    position: (143, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (144, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ClusterRoleBinding",
                    position: (144, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (145, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "annotations",
                       position: (146, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "rbac.authorization.kubernetes.io/autoupdate",
                             position: (147, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (147, 62),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (146, 25),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (149, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (150, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Reconcile",
                          position: (150, 50),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (151, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (151, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (152, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (152, 48),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/bootstrapping",
                             position: (153, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "rbac-defaults",
                          position: (153, 46),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (149, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (155, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "system:coredns",
                       position: (155, 19),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (145, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "roleRef",
                    position: (157, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "apiGroup",
                       position: (158, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "rbac.authorization.k8s.io",
                       position: (158, 23),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "kind",
                       position: (159, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "ClusterRole",
                       position: (159, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (160, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "system:coredns",
                       position: (160, 19),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (157, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "subjects",
                    position: (162, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "kind",
                         position: (164, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "ServiceAccount",
                         position: (164, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "name",
                         position: (165, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "coredns",
                         position: (165, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "namespace",
                         position: (166, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "kube-system",
                         position: (166, 26),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (163, 11),
                   },
                  ],
                  position: (162, 20),
                 },
                ),
               ],
               recursive: false,
               position: (142, 21),
              },
             ),
            ],
            recursive: false,
            position: (115, 56),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (172, 5),
             },
             Raw {
              content: "kubernetes",
              position: (172, 14),
             },
             Raw {
              content: "addonManager",
              position: (172, 25),
             },
             Raw {
              content: "addons",
              position: (172, 38),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-sa",
                 position: (173, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (174, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "v1",
                    position: (174, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (175, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ServiceAccount",
                    position: (175, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (176, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (177, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (178, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Reconcile",
                          position: (178, 50),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (179, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (179, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (180, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (180, 48),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (177, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (182, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "coredns",
                       position: (182, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "namespace",
                       position: (183, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "kube-system",
                       position: (183, 24),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (176, 20),
                 },
                ),
               ],
               recursive: false,
               position: (173, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-cm",
                 position: (187, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (188, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "v1",
                    position: (188, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (189, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "ConfigMap",
                    position: (189, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (190, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (191, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (192, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (192, 49),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "reconcileMode",
                           position: (192, 53),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (193, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (193, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (194, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (194, 48),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (191, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (196, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "coredns",
                       position: (196, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "namespace",
                       position: (197, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "kube-system",
                       position: (197, 24),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (190, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "data",
                    position: (199, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "Corefile",
                       position: (200, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (200, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "corefile",
                        position: (200, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                  ],
                  recursive: false,
                  position: (199, 16),
                 },
                ),
               ],
               recursive: false,
               position: (187, 20),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-deploy",
                 position: (204, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (205, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "apps/v1",
                    position: (205, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (206, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Deployment",
                    position: (206, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (207, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (208, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (209, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (209, 49),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "reconcileMode",
                           position: (209, 53),
                          },
                         ],
                        },
                        default: None,
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (210, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (210, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (211, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (211, 48),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/name",
                             position: (212, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "CoreDNS",
                          position: (212, 37),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (208, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (214, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "coredns",
                       position: (214, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "namespace",
                       position: (215, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "kube-system",
                       position: (215, 24),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (207, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "spec",
                    position: (217, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "replicas",
                       position: (218, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (218, 22),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "replicas",
                        position: (218, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "selector",
                       position: (219, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "matchLabels",
                          position: (220, 13),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "k8s-app",
                             position: (220, 29),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "kube-dns",
                             position: (220, 40),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (220, 27),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (219, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "strategy",
                       position: (222, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "rollingUpdate",
                          position: (223, 13),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "maxUnavailable",
                             position: (223, 31),
                            },
                           ],
                          },
                          Int {
                           value: 1,
                           position: (223, 48),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (223, 29),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "type",
                          position: (224, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "RollingUpdate",
                          position: (224, 21),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (222, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "template",
                       position: (226, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "metadata",
                          position: (227, 13),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "labels",
                             position: (228, 15),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "k8s-app",
                                position: (229, 17),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "kube-dns",
                                position: (229, 28),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (228, 24),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (227, 24),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "spec",
                          position: (232, 13),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "containers",
                             position: (233, 15),
                            },
                           ],
                          },
                          List {
                           elements: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "args",
                                  position: (235, 19),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "-conf",
                                    position: (235, 29),
                                   },
                                  ],
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "/etc/coredns/Corefile",
                                    position: (235, 37),
                                   },
                                  ],
                                 },
                                ],
                                position: (235, 26),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "image",
                                  position: (236, 19),
                                 },
                                ],
                               },
                               With {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (236, 32),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "coredns",
                                    position: (236, 36),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                target: String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "imageName",
                                    position: (236, 48),
                                   },
                                  },
                                  Raw {
                                   content: ":",
                                   position: (236, 58),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "finalImageTag",
                                    position: (236, 61),
                                   },
                                  },
                                 ],
                                },
                                position: (236, 27),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "imagePullPolicy",
                                  position: (237, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Never",
                                  position: (237, 38),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "livenessProbe",
                                  position: (238, 19),
                                 },
                                ],
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "failureThreshold",
                                     position: (239, 21),
                                    },
                                   ],
                                  },
                                  Int {
                                   value: 5,
                                   position: (239, 40),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "httpGet",
                                     position: (240, 21),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "path",
                                        position: (241, 23),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "/health",
                                        position: (241, 31),
                                       },
                                      ],
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "port",
                                        position: (242, 23),
                                       },
                                      ],
                                     },
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "ports",
                                       position: (242, 30),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "health",
                                         position: (242, 36),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "scheme",
                                        position: (243, 23),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "HTTP",
                                        position: (243, 33),
                                       },
                                      ],
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (240, 31),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "initialDelaySeconds",
                                     position: (245, 21),
                                    },
                                   ],
                                  },
                                  Int {
                                   value: 60,
                                   position: (245, 43),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "successThreshold",
                                     position: (246, 21),
                                    },
                                   ],
                                  },
                                  Int {
                                   value: 1,
                                   position: (246, 40),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "timeoutSeconds",
                                     position: (247, 21),
                                    },
                                   ],
                                  },
                                  Int {
                                   value: 5,
                                   position: (247, 38),
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (238, 35),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "name",
                                  position: (249, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "coredns",
                                  position: (249, 27),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "ports",
                                  position: (250, 19),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "containerPort",
                                       position: (252, 23),
                                      },
                                     ],
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "ports",
                                      position: (252, 39),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "dns",
                                        position: (252, 45),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "name",
                                       position: (253, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "dns",
                                       position: (253, 31),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "protocol",
                                       position: (254, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "UDP",
                                       position: (254, 35),
                                      },
                                     ],
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (251, 21),
                                 },
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "containerPort",
                                       position: (257, 23),
                                      },
                                     ],
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "ports",
                                      position: (257, 39),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "dns",
                                        position: (257, 45),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "name",
                                       position: (258, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "dns-tcp",
                                       position: (258, 31),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "protocol",
                                       position: (259, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "TCP",
                                       position: (259, 35),
                                      },
                                     ],
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (256, 21),
                                 },
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "containerPort",
                                       position: (262, 23),
                                      },
                                     ],
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "ports",
                                      position: (262, 39),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "metrics",
                                        position: (262, 45),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "name",
                                       position: (263, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "metrics",
                                       position: (263, 31),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "protocol",
                                       position: (264, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "TCP",
                                       position: (264, 35),
                                      },
                                     ],
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (261, 21),
                                 },
                                ],
                                position: (250, 27),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "resources",
                                  position: (267, 19),
                                 },
                                ],
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "limits",
                                     position: (268, 21),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "memory",
                                        position: (269, 23),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "170Mi",
                                        position: (269, 33),
                                       },
                                      ],
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (268, 30),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "requests",
                                     position: (271, 21),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "cpu",
                                        position: (272, 23),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "100m",
                                        position: (272, 30),
                                       },
                                      ],
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "memory",
                                        position: (273, 23),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "70Mi",
                                        position: (273, 33),
                                       },
                                      ],
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (271, 32),
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (267, 31),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "securityContext",
                                  position: (276, 19),
                                 },
                                ],
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "allowPrivilegeEscalation",
                                     position: (277, 21),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "false",
                                   position: (277, 48),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "capabilities",
                                     position: (278, 21),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "drop",
                                        position: (279, 23),
                                       },
                                      ],
                                     },
                                     List {
                                      elements: [
                                       String {
                                        parts: [
                                         Raw {
                                          content: "all",
                                          position: (279, 33),
                                         },
                                        ],
                                       },
                                      ],
                                      position: (279, 30),
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (278, 36),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "readOnlyRootFilesystem",
                                     position: (281, 21),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "true",
                                   position: (281, 46),
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (276, 37),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "volumeMounts",
                                  position: (283, 19),
                                 },
                                ],
                               },
                               List {
                                elements: [
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "mountPath",
                                       position: (285, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "/etc/coredns",
                                       position: (285, 36),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "name",
                                       position: (286, 23),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "config-volume",
                                       position: (286, 31),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "readOnly",
                                       position: (287, 23),
                                      },
                                     ],
                                    },
                                    Variable {
                                     identifier: "true",
                                     position: (287, 34),
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (284, 21),
                                 },
                                ],
                                position: (283, 34),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (234, 17),
                            },
                           ],
                           position: (233, 28),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "dnsPolicy",
                             position: (292, 15),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "Default",
                             position: (292, 28),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "nodeSelector",
                             position: (293, 15),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Expression {
                                expression: String {
                                 parts: [
                                  Raw {
                                   content: "beta.kubernetes.io/os",
                                   position: (294, 18),
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "linux",
                                position: (294, 44),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (293, 30),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "serviceAccountName",
                             position: (296, 15),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "coredns",
                             position: (296, 37),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "tolerations",
                             position: (297, 15),
                            },
                           ],
                          },
                          List {
                           elements: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "effect",
                                  position: (299, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "NoSchedule",
                                  position: (299, 29),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "key",
                                  position: (300, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "node-role.kubernetes.io/master",
                                  position: (300, 26),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (298, 17),
                            },
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "key",
                                  position: (303, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "CriticalAddonsOnly",
                                  position: (303, 26),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "operator",
                                  position: (304, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Exists",
                                  position: (304, 31),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (302, 17),
                            },
                           ],
                           position: (297, 29),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "volumes",
                             position: (307, 15),
                            },
                           ],
                          },
                          List {
                           elements: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "configMap",
                                  position: (309, 19),
                                 },
                                ],
                               },
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "items",
                                     position: (310, 21),
                                    },
                                   ],
                                  },
                                  List {
                                   elements: [
                                    Map {
                                     bindings: [
                                      KeyValue(
                                       AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "key",
                                          position: (312, 25),
                                         },
                                        ],
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "Corefile",
                                          position: (312, 32),
                                         },
                                        ],
                                       },
                                      ),
                                      KeyValue(
                                       AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "path",
                                          position: (313, 25),
                                         },
                                        ],
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "Corefile",
                                          position: (313, 33),
                                         },
                                        ],
                                       },
                                      ),
                                     ],
                                     recursive: false,
                                     position: (311, 23),
                                    },
                                   ],
                                   position: (310, 29),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "name",
                                     position: (316, 21),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "coredns",
                                     position: (316, 29),
                                    },
                                   ],
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (309, 31),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "name",
                                  position: (318, 19),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "config-volume",
                                  position: (318, 27),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (308, 17),
                            },
                           ],
                           position: (307, 25),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (232, 20),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (226, 22),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (217, 16),
                 },
                ),
               ],
               recursive: false,
               position: (204, 24),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "coredns-svc",
                 position: (326, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apiVersion",
                    position: (327, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "v1",
                    position: (327, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "kind",
                    position: (328, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Service",
                    position: (328, 17),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "metadata",
                    position: (329, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "annotations",
                       position: (330, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "prometheus.io/port",
                             position: (331, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "toString",
                         position: (331, 36),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "ports",
                           position: (331, 45),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "metrics",
                             position: (331, 51),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "prometheus.io/scrape",
                             position: (332, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (332, 39),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (330, 25),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "labels",
                       position: (334, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "addonmanager.kubernetes.io/mode",
                             position: (335, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "Reconcile",
                          position: (335, 50),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (336, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (336, 24),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/cluster-service",
                             position: (337, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "true",
                          position: (337, 48),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "kubernetes.io/name",
                             position: (338, 14),
                            },
                           ],
                          },
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "CoreDNS",
                          position: (338, 37),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (334, 20),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "name",
                       position: (340, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "kube-dns",
                       position: (340, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "namespace",
                       position: (341, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "kube-system",
                       position: (341, 24),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (329, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "spec",
                    position: (343, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "clusterIP",
                       position: (344, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (344, 23),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "clusterIp",
                        position: (344, 27),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ports",
                       position: (345, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "name",
                            position: (347, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "dns",
                            position: (347, 23),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "port",
                            position: (348, 15),
                           },
                          ],
                         },
                         Int {
                          value: 53,
                          position: (348, 22),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "targetPort",
                            position: (349, 15),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "ports",
                           position: (349, 28),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "dns",
                             position: (349, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "protocol",
                            position: (350, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "UDP",
                            position: (350, 27),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (346, 13),
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "name",
                            position: (353, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "dns-tcp",
                            position: (353, 23),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "port",
                            position: (354, 15),
                           },
                          ],
                         },
                         Int {
                          value: 53,
                          position: (354, 22),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "targetPort",
                            position: (355, 15),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "ports",
                           position: (355, 28),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "dns",
                             position: (355, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "protocol",
                            position: (356, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "TCP",
                            position: (356, 27),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (352, 13),
                      },
                     ],
                     position: (345, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "selector",
                       position: (359, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "k8s-app",
                          position: (359, 24),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "kube-dns",
                          position: (359, 35),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (359, 22),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (343, 16),
                 },
                ),
               ],
               recursive: false,
               position: (326, 21),
              },
             ),
            ],
            recursive: false,
            position: (172, 47),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (364, 5),
             },
             Raw {
              content: "kubernetes",
              position: (364, 14),
             },
             Raw {
              content: "kubelet",
              position: (364, 25),
             },
             Raw {
              content: "clusterDns",
              position: (364, 33),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (364, 46),
            },
            arguments: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (364, 56),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "clusterIp",
                 position: (364, 60),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (111, 28),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (367, 3),
        },
        Raw {
         content: "buildDocsInSandbox",
         position: (367, 8),
        },
       ],
      },
      Variable {
       identifier: "false",
       position: (367, 29),
      },
     ),
    ],
    recursive: false,
    position: (13, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}