{{- range .Entries }}
	{{- if and (not .Resource.Synthetic) (not .Resource.Builtin) }}
	case gvk.{{.Resource.Identifier}}:
		return c.{{.ClientGetter}}().{{ .ClientGroupPath }}().{{ .ClientTypePath }}({{if not .Resource.ClusterScoped}}cfg.Namespace{{end}}).Create(context.TODO(), &{{ .IstioAwareClientImport }}.{{ .Resource.Kind }}{
			ObjectMeta: objMeta,
			Spec:       *(cfg.Spec.(*{{ .ClientImport }}.{{.SpecType}})),
		}, metav1.CreateOptions{})

										Default: "",
										Type:    []string{"string"},
										Format:  "",
									},
								},
							},
						},
					},
					"clusterScope": {
						SchemaProps: spec.SchemaProps{

	// with the cmp library.
	Equal(other Schema) bool
}

// Builder for a Schema.
type Builder struct {
	// ClusterScoped is true for resource in cluster-level.
	ClusterScoped bool

	// Synthetic is true for resource that do not actually exist in a cluster
	Synthetic bool

	// Builtin is true for resources that are builtin (not CRD)
	Builtin bool

	Version            string   `json:"version"`
	VersionAliases     []string `json:"versionAliases"`
	Kind               string   `json:"kind"`
	Plural             string   `json:"plural"`
	ClusterScoped      bool     `json:"clusterScoped"`
	Builtin            bool     `json:"builtin"`
	Specless           bool     `json:"specless"`
	Synthetic          bool     `json:"synthetic"`
	Proto              string   `json:"proto"`

			}
			selectableFields[gv] = fieldPaths
		}
	}

	unsafe = &crConverter{
		convertScale:     convertScale,
		validVersions:    validVersions,
		clusterScoped:    crd.Spec.Scope == apiextensionsv1.ClusterScoped,
		converter:        converter,
		selectableFields: selectableFields,
	}
	return &safeConverterWrapper{unsafe}, unsafe, nil
}

			ProtoPackage: "{{ .Resource.ProtoPackage }}",
			{{- if ne "" .Resource.StatusProtoPackage}}StatusPackage: "{{ .Resource.StatusProtoPackage }}", {{end}}
			ClusterScoped: {{ .Resource.ClusterScoped }},
			Synthetic: {{ .Resource.Synthetic }},
			Builtin: {{ .Resource.Builtin }},
			ValidateProto: {{ .Resource.Validate }},
		}.MustBuild()
{{ end }}

	// All contains all collections in the system.

	tearDown, apiExtensionClient, dynamicClient, err := fixtures.StartDefaultServerWithClients(t)
	require.NoError(t, err)
	defer tearDown()

	noxuDefinition := fixtures.NewNoxuV1CustomResourceDefinition(apiextensionsv1.ClusterScoped)
	noxuDefinition, err = fixtures.CreateNewV1CustomResourceDefinition(noxuDefinition, apiExtensionClient, dynamicClient)
	require.NoError(t, err)

	ns := "not-the-default"
	name := "foo123"

	Plural:        "Kind1s",
	Version:       "v1alpha1",
	Proto:         "google.protobuf.Struct",
	ReflectType:   reflect.TypeOf(&structpb.Struct{}).Elem(),
	ProtoPackage:  "github.com/gogo/protobuf/types",
	ClusterScoped: false,
	ValidateProto: validation.EmptyValidate,
}.MustBuild()

func createTestResource(t *testing.T, ns, name, version string) *resource.Instance {
	t.Helper()

	"istio.io/istio/pkg/config/schema/resource"
	"istio.io/istio/pkg/config/validation"
	testconfig "istio.io/istio/pkg/test/config"
)

var (
	// Mock is used purely for testing
	Mock = resource.Builder{
		ClusterScoped: false,
		Kind:          "MockConfig",
		Plural:        "mockconfigs",
		Group:         "test.istio.io",
		Version:       "v1",
		Proto:         "config.MockConfig",
		ProtoPackage:  "istio.io/istio/pkg/test/config",

	if err != nil {
		t.Fatal(err)
	}
	defer tearDown()

	for _, scope := range []apiextensionsv1.ResourceScope{apiextensionsv1.ClusterScoped, apiextensionsv1.NamespaceScoped} {
		t.Run(string(scope), func(t *testing.T) {

			crd := &apiextensionsv1.CustomResourceDefinition{
				ObjectMeta: metav1.ObjectMeta{