err:       &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "Foo"}},
		},
		{
			name:      "ignore not found with version not exist",
			mapper:    MultiRESTMapper{fixedRESTMapper{err: &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "Foo"}, SearchedVersions: []string{"v1"}}}},
			groupKind: schema.GroupKind{Kind: "Foo"},
			versions:  []string{"v1beta"},
			result:    nil,

	return ok
}

// NoKindMatchError is returned if the RESTMapper can't find any match for a kind
type NoKindMatchError struct {
	// GroupKind is the API group and kind that was searched
	GroupKind schema.GroupKind
	// SearchedVersions is the optional list of versions the search was restricted to
	SearchedVersions []string
}

func (e *NoKindMatchError) Error() string {
	searchedVersions := sets.NewString()

			new:         func() error { return &NoResourceMatchError{} },
			matcherFunc: IsNoMatchError,
		},
		{
			name:        "NoKindMatchError",
			input:       &NoKindMatchError{SearchedVersions: []string{"foo"}},
			new:         func() error { return &NoKindMatchError{} },
			matcherFunc: IsNoMatchError,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {

		}
		return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
	}
	if len(errors) > 0 {
		return nil, utilerrors.NewAggregate(errors)
	}
	return nil, &NoKindMatchError{GroupKind: gk, SearchedVersions: versions}
}

// RESTMappings returns all possible RESTMappings for the provided group kind, or an error
// if the type is not recognized.

		}
		if resource.Version != "" && resource.Version != gvk.Version {
			// version didn't match
			continue
		}
		return gv.WithResource(resource.Name), nil
	}
	return schema.GroupVersionResource{}, &meta.NoKindMatchError{GroupKind: gvk.GroupKind(), SearchedVersions: []string{gvk.Version}}
}

func NewDiscoveryResourceResolver(client discovery.DiscoveryInterface) (ResourceResolver, error) {

			input:  schema.GroupKind{Kind: "Foo"},
			err:    &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "Foo"}},
		},
		{
			name:   "ignore not found",
			mapper: PriorityRESTMapper{Delegate: MultiRESTMapper{fixedRESTMapper{err: &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "IGNORE_THIS"}}}}},
			input:  schema.GroupKind{Kind: "Foo"},
			err:    &NoKindMatchError{GroupKind: schema.GroupKind{Kind: "Foo"}},
		},
		{

		restMapper, err := m.restMapperFn()
		if err != nil {
			return nil, err
		}
		mapping, err := restMapper.RESTMapping(gvk.GroupKind(), gvk.Version)
		if err != nil {
			if _, ok := err.(*meta.NoKindMatchError); ok {
				return nil, fmt.Errorf("resource mapping not found for name: %q namespace: %q from %q: %w\nensure CRDs are installed first",
					name, namespace, source, err)
			}

	mappings, err := m.RESTMappings(gk, versions...)
	if err != nil {
		return nil, err
	}
	if len(mappings) == 0 {
		return nil, &NoKindMatchError{GroupKind: gk, SearchedVersions: versions}
	}
	// since we rely on RESTMappings method
	// take the first match and return to the caller
	// as this was the existing behavior.
	return mappings[0], nil
}

		// for the given argument. To maintain consistency with previous behavior,
		// announce that a resource type could not be found.
		// if the error is _not_ a *meta.NoKindMatchError, then we had trouble doing discovery,
		// so we should return the original error since it may help a user diagnose what is actually wrong
		if meta.IsNoMatchError(err) {

	}

	test := &testVisitor{}
	singleItemImplied := false

	b.ResourceTypeOrNameArgs(true, "foo", "bar")

	// ensure that requesting a resource we _know_ not to exist results in an expected *meta.NoKindMatchError
	err := b.Do().IntoSingleItemImplied(&singleItemImplied).Visit(test.Handle)
	if err != nil {
		if !strings.Contains(err.Error(), "server doesn't have a resource type \"foo\"") {