Node: &core.Node{
			Id:       ads.ID,
			Metadata: metadata,
		},
		TypeUrl: v3.ClusterType,
	})

	clusterName := "outbound|1080||service5.default.svc.cluster.local"
	res := ads.RequestResponseAck(t, &discovery.DiscoveryRequest{
		Node: &core.Node{
			Id:       ads.ID,
			Metadata: metadata,
		},
		TypeUrl:       v3.EndpointType,
		ResourceNames: []string{clusterName},
	})

			TransportSocket: &core.TransportSocket{
				Name: "transport_sockets.alts",
				ConfigType: &core.TransportSocket_TypedConfig{
					TypedConfig: protoconv.MessageToAny(&udpa.TypedStruct{
						TypeUrl: "type.googleapis.com/envoy.extensions.transport_sockets.alts.v3.Alts",
						Value:   buildGolangPatchStruct(`{"handshaker_service":"1.2.3.4"}`),
					}),
				},
			},
		},
		{

      ],
      "github.com/gogo/protobuf": [
        "github.com/Microsoft/hcsshim",
        "github.com/containerd/cgroups",
        "github.com/containerd/ttrpc",
        "github.com/containerd/typeurl",
        "github.com/google/cadvisor",
        "github.com/grpc-ecosystem/go-grpc-middleware",
        "go.etcd.io/etcd/api/v3",
        "go.etcd.io/etcd/client/v3",
        "go.etcd.io/etcd/raft/v3",

	f.t.Helper()
	p = f.SetupProxy(p)
	initialWatch := []*discovery.DiscoveryRequest{}
	for _, typeURL := range watch {
		initialWatch = append(initialWatch, &discovery.DiscoveryRequest{TypeUrl: typeURL})
	}
	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
	if f.BufListener != nil {

	}

	// gogo protobuf
	if pb, ok := s.(gogoproto.Message); ok {
		gogoany, err := gogotypes.MarshalAny(pb)
		if err != nil {
			return nil, err
		}
		return &anypb.Any{
			TypeUrl: gogoany.TypeUrl,
			Value:   gogoany.Value,
		}, nil
	}

	js, err := json.Marshal(s)
	if err != nil {
		return nil, err
	}
	pbs := &structpb.Struct{}

		proxy := ds.SetupProxy(&model.Proxy{Metadata: &model.NodeMetadata{
			Generator: "grpc",
		}})
		adscConn := ds.Connect(proxy, []string{}, []string{})

		adscConn.Send(&discovery.DiscoveryRequest{
			TypeUrl: v3.ListenerType,
		})

		msg, err := adscConn.WaitVersion(5*time.Second, v3.ListenerType, "")
		if err != nil {
			t.Fatal("Failed to receive lds", err)
		}

		writeJSON(w, res, req)
		return
	}
	snapshot := s.Cache.Snapshot()
	resources := make(map[string][]string, len(snapshot)) // Key is typeUrl and value is resource names.
	for _, resource := range snapshot {
		if resource == nil {
			continue
		}
		resourceType := resource.Resource.TypeUrl
		resources[resourceType] = append(resources[resourceType], resource.Name)
	}
	writeJSON(w, resources, req)
}

	github.com/census-instrumentation/opencensus-proto v0.4.1 // indirect
	github.com/chai2010/gettext-go v1.0.2 // indirect
	github.com/containerd/stargz-snapshotter/estargz v0.15.1 // indirect
	github.com/containerd/typeurl/v2 v2.1.1 // indirect
	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect

	// Key is the generator type - will match the Generator metadata to set the per-connection
	// default generator, or the combination of Generator metadata and TypeUrl to select a
	// different generator for a type.
	// Normal istio clients use the default generator - will not be impacted by this.
	Generators map[string]model.XdsResourceGenerator

			return allMetrics
		}
		return []string{m.Metric.String()}
	default:
		return allMetrics
	}
}

var waypointStatsConfig = protoconv.MessageToAny(&udpa.TypedStruct{
	TypeUrl: "type.googleapis.com/stats.PluginConfig",
	Value: &structpb.Struct{
		Fields: map[string]*structpb.Value{
			"reporter": {
				Kind: &structpb.Value_StringValue{
					StringValue: "SERVER_GATEWAY",
				},