"typed_config": {
                            "@type": "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router"
                          }
                        }
                      ]
                    }
                  }
                ]
              }
            ]
          },
          "last_updated": "2023-12-26T05:57:09.902Z"

                            }
                          },
                          {
                            "name": "envoy.filters.http.router",
                            "typed_config": {
                              "@type": "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router"
                            }
                          }
                        ],
                        "http2_protocol_options": {

                            }
                          },
                          {
                            "name": "envoy.filters.http.router",
                            "typed_config": {
                              "@type": "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router"
                            }
                          }
                        ],
                        "http2_protocol_options": {

			for _, route := range vh.Routes {
				if routeDestinationMatchesSvc(route, svc, vh, port) {
					return getIstioConfig(route.Metadata)
				}
			}
		}
	}
	return "", nil
}

// routeDestinationMatchesSvc determines whether or not to use this service as a destination
func routeDestinationMatchesSvc(vhRoute *route.Route, svc corev1.Service, vh *route.VirtualHost, port int32) bool {

    assertThat(response.body.string()).isEqualTo("abc")
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    // Note that although we have two routes available, we only use one. The retry is permitted
    // because there are routes available, but it chooses the existing connection since it isn't
    // yet considered unhealthy.
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(1)
  }

    )
    def post_router(item1: Item, item2: Item):
        return item1, item2  # pragma: nocover

    @sub_router.post(
        "/subrouter",
        response_model=List[Item],
        responses={404: {"model": List[Message]}},
    )
    def post_subrouter(item1: Item, item2: Item):
        return item1, item2  # pragma: nocover

    router.include_router(sub_router)

func registerAPIFunctions(muxRouter *mux.Router, objLayer ObjectLayer, apiFunctions ...string) {
	if len(apiFunctions) == 0 {
		// Register all api endpoints by default.
		registerAPIRouter(muxRouter)
		return
	}
	// API Router.
	apiRouter := muxRouter.PathPrefix(SlashSeparator).Subrouter()
	// Bucket router.

              },
              "expr": "sum(irate(pilot_xds_pushes{type=\"rds\"}[1m]))",
              "format": "time_series",
              "intervalFactor": 1,
              "legendFormat": "Routes",
              "refId": "E"
            },
            {
              "datasource": {
                "type": "prometheus",
                "uid": "${datasource}"
              },

                        type: string
                      type: object
                  type: object
                type: array
              password:
                description: Authentication password for routers enforcing TCP MD5
                  authenticated sessions
                type: string
              peerASN:
                description: AS number to expect from the remote end of the session.

                        }
                    },
                    "summary": "Non Decorated Route",
                    "operationId": "non_decorated_route_non_decorated_route_get",
                }
            },
            "/text": {
                "get": {
                    "responses": {
                        "200": {
                            "description": "Successful Response",