return nil, model.DefaultXdsLogDetails, err
	}

	buffer := processDebugRequest(dg, resourceName)

	res := model.Resources{&discovery.Resource{
		Name: resourceName,
		Resource: &anypb.Any{
			TypeUrl: v3.DebugType,
			Value:   buffer.Bytes(),
		},
	}}
	return res, model.DefaultXdsLogDetails, nil
}

// GenerateDeltas XDS debug responses according to the incoming debug request

	case *matcher.Matcher_MatcherTree_PrefixMatchMap:
		m = v.PrefixMatchMap.Map
		equality = "^"
	case *matcher.Matcher_MatcherTree_CustomMatch:
		tc := v.CustomMatch.GetTypedConfig()
		switch tc.TypeUrl {
		case IPMatcher:
			ip := protoconv.SilentlyUnmarshalAny[matcher.IPMatcher](tc)
			m = map[string]*matcher.Matcher_OnMatch{}
			for _, rm := range ip.GetRangeMatchers() {
				for _, r := range rm.Ranges {

// limitations under the License.

package xds

import (
	v3 "istio.io/istio/pilot/pkg/xds/v3"
	"istio.io/istio/pkg/util/sets"
)

// EventType represents the type of object we are tracking, mapping to envoy TypeUrl.
type EventType = string

var AllTrackingEventTypes = sets.New[EventType](
	v3.ClusterType,
	v3.ListenerType,
	v3.RouteType,
	v3.EndpointType,
)

	resources := make([]*anypb.Any, 0, len(p))
	for _, v := range p {
		resources = append(resources, protoconv.MessageToAny(v))
	}
	return &discovery.DiscoveryResponse{
		Resources: resources,
		TypeUrl:   resources[0].TypeUrl,
	}
}

// DumpList will dump a list of protos.
func DumpList[T any](t test.Failer, protoList []T) []string {
	res := []string{}
	for _, i := range protoList {
		p, ok := any(i).(proto.Message)

	if err != nil {
		return nil, err
	}
	dac := clusterDump.GetDynamicActiveClusters()
	// Allow sorting to work even if we don't have the exact same type
	for i := range dac {
		dac[i].Cluster.TypeUrl = v3.ClusterType
	}
	sort.Slice(dac, func(i, j int) bool {
		cluster := &cluster.Cluster{}
		err = dac[i].Cluster.UnmarshalTo(cluster)
		if err != nil {
			return false
		}
		name := cluster.Name

	s := xdsfake.NewFakeDiscoveryServer(t, xdsfake.FakeOptions{})

	ads := s.ConnectADS()
	// Send normal CDS and EDS requests
	_ = ads.RequestResponseAck(t, &discovery.DiscoveryRequest{TypeUrl: v3.ClusterType})
	eres := ads.RequestResponseAck(t, &discovery.DiscoveryRequest{TypeUrl: v3.EndpointType, ResourceNames: []string{"my-resource"}})

	// A push should get a response for both
	s.Discovery.ConfigUpdate(&model.PushRequest{Full: true})
	ads.ExpectResponse(t)

				}
				if err != nil {
					return fmt.Errorf("could not contact sidecar: %w", err)
				}

				xdsRequest := discovery.DiscoveryRequest{
					ResourceNames: []string{fmt.Sprintf("%s.%s", podName, ns)},
					TypeUrl:       pilotxds.TypeDebugConfigDump,
				}
				xdsResponses, err := multixds.FirstRequestAndProcessXds(&xdsRequest, centralOpts, ctx.IstioNamespace(), "", "", kubeClient, multiXdsOpts)
				if err != nil {
					return err

	var namespace, serviceAccount string
	xdsRequest := discovery.DiscoveryRequest{
		ResourceNames: []string{"list"},
		Node: &core.Node{
			Id: "debug~0.0.0.0~istioctl~cluster.local",
		},
		TypeUrl: v3.DebugType,
	}
	xdsResponses, respErr := multixds.AllRequestAndProcessXds(&xdsRequest, centralOpts, istioNamespace,
		namespace, serviceAccount, kubeClient, multixds.DefaultOptions)
	if respErr != nil {

	for _, c := range clusterDump.DynamicActiveClusters {
		if c.Cluster != nil {
			clusterTyped := &cluster.Cluster{}
			// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
			c.Cluster.TypeUrl = v3.ClusterType
			err = c.Cluster.UnmarshalTo(clusterTyped)
			if err != nil {
				return nil, err
			}
			clusters = append(clusters, clusterTyped)
		}
	}
	for _, c := range clusterDump.StaticClusters {

		l.DrainingState = nil
		if l.ActiveState != nil {
			dal = append(dal, l)
		}
	}

	// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
	for i := range dal {
		dal[i].ActiveState.Listener.TypeUrl = v3.ListenerType
	}
	sort.Slice(dal, func(i, j int) bool {
		l := &listener.Listener{}
		err = dal[i].ActiveState.Listener.UnmarshalTo(l)
		if err != nil {
			return false
		}
		name := l.Name