GroupVersionKind() config.GroupVersionKind

	// GroupVersionResource of the resource.
	GroupVersionResource() schema.GroupVersionResource

	// IsClusterScoped indicates that this resource is scoped to a particular namespace within a cluster.
	IsClusterScoped() bool

	// IsBuiltin indicates that this resource is builtin (not a CRD)
	IsBuiltin() bool

	// Identifier returns a unique identifier for the resource

	{{$entry.Resource.Identifier}}_{{$alias}} = schema.GroupVersionResource{Group: "{{$entry.Resource.Group}}", Version: "{{$alias}}", Resource: "{{$entry.Resource.Plural}}"}
    {{- end }}
{{- end }}
)

func IsClusterScoped(g schema.GroupVersionResource) bool {
	switch g {
{{- range $entry := .Entries }}
	{{- if not $entry.Resource.Synthetic }}
	case {{$entry.Resource.Identifier}}:
		return {{$entry.Resource.ClusterScoped}}

	}
}

func schemaWithValidateFn(validateFn func(cfg config.Config) (validation.Warning, error)) resource2.Schema {
	original := collections.VirtualService
	return resource2.Builder{
		ClusterScoped: original.IsClusterScoped(),
		Kind:          original.Kind(),
		Plural:        original.Plural(),
		Group:         original.Group(),
		Version:       original.Version(),
		Proto:         original.Proto(),

		name := r.Kind()
		t.Run(name, func(t *testing.T) {
			configMeta := config.Meta{
				GroupVersionKind: r.GroupVersionKind(),
				Name:             configName,
			}
			if !r.IsClusterScoped() {
				configMeta.Namespace = configNamespace
			}
			pb := createResource(t, store, r, configMeta)

			// Kubernetes is eventually consistent, so we allow a short time to pass before we get

	WorkloadGroup_v1               = schema.GroupVersionResource{Group: "networking.istio.io", Version: "v1", Resource: "workloadgroups"}
)

func IsClusterScoped(g schema.GroupVersionResource) bool {
	switch g {
	case ServiceExport:
		return false
	case ServiceImport:
		return false
	case AuthorizationPolicy:
		return false
	case AuthorizationPolicy_v1:

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			configMeta := config2.Meta{
				GroupVersionKind: c.schema.GroupVersionKind(),
				Name:             c.configName,
			}
			if !c.schema.IsClusterScoped() {
				configMeta.Namespace = namespace
			}

			if _, err := store.Create(config2.Config{
				Meta: configMeta,
				Spec: c.spec,
			}); err != nil {
				t.Errorf("Post(%v) => got %v", c.name, err)

		return name
	}
	return namespace + "/" + name
}

func ToOpts(c kube.Client, gvr schema.GroupVersionResource, filter Filter) kubetypes.InformerOptions {
	ns := filter.Namespace
	if !istiogvr.IsClusterScoped(gvr) && ns == "" {
		ns = features.InformerWatchNamespace
	}
	return kubetypes.InformerOptions{
		LabelSelector:   filter.LabelSelector,
		FieldSelector:   filter.FieldSelector,
		Namespace:       ns,

	var extraFilter func(obj any) bool
	if of, f := cl.filtersByGVK[resourceGVK]; f && of.ObjectFilter != nil {
		extraFilter = of.ObjectFilter.Filter
	}

	var namespaceFilter kubetypes.DynamicObjectFilter
	if !s.IsClusterScoped() {
		namespaceFilter = kube.FilterIfEnhancedFilteringEnabled(cl.client)
	}
	filter := kubetypes.Filter{ObjectFilter: composeFilters(namespaceFilter, cl.inRevision, extraFilter)}

	var kc kclient.Untyped

	// If namespace is blank and we have a default set, fill in the default
	// (This mirrors the behavior if you kubectl apply a resource without a namespace defined)
	// Don't do this for cluster scoped resources
	if !schema.IsClusterScoped() {
		if objMeta.GetNamespace() == "" && s.defaultNs != "" {
			scope.Debugf("KubeSource.parseChunk: namespace not specified for %q, using %q", objMeta.GetName(), s.defaultNs)
			objMeta.SetNamespace(string(s.defaultNs))