_, ok := target.(*AmbiguousResourceError)
	return ok
}

// AmbiguousKindError is returned if the RESTMapper finds multiple matches for a kind
type AmbiguousKindError struct {
	PartialKind schema.GroupVersionKind

	MatchingResources []schema.GroupVersionResource
	MatchingKinds     []schema.GroupVersionKind
}

func (e *AmbiguousKindError) Error() string {
	switch {

			new:         func() error { return &AmbiguousResourceError{} },
			matcherFunc: IsAmbiguousError,
		},
		{
			name:        "AmbiguousKindError",
			input:       &AmbiguousKindError{MatchingResources: []schema.GroupVersionResource{{}}},
			new:         func() error { return &AmbiguousKindError{} },
			matcherFunc: IsAmbiguousError,
		},
		{
			name:        "NoResourceMatchError",

		return allMappings[0], nil
	}
	if len(allMappings) > 1 {
		var kinds []schema.GroupVersionKind
		for _, m := range allMappings {
			kinds = append(kinds, m.GroupVersionKind)
		}
		return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
	}
	if len(errors) > 0 {
		return nil, utilerrors.NewAggregate(errors)
	}
	return nil, &NoKindMatchError{GroupKind: gk, SearchedVersions: versions}
}

	}
	if len(remaining) == 1 {
		return remaining[0], originalErr
	}

	var kinds []schema.GroupVersionKind
	for _, m := range mappings {
		kinds = append(kinds, m.GroupVersionKind)
	}
	return nil, &AmbiguousKindError{PartialKind: gk.WithVersion(""), MatchingKinds: kinds}
}

func (m PriorityRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) ([]*RESTMapping, error) {
	return m.Delegate.RESTMappings(gk, versions...)

			err:    errors.New("fail on this"),
		},
		{
			name: "return error for ambiguous",
			mapper: PriorityRESTMapper{
				Delegate: allMappers,
			},
			input: schema.GroupKind{Kind: "Foo"},
			err: &AmbiguousKindError{
				PartialKind: schema.GroupVersionKind{Kind: "Foo"},
				MatchingKinds: []schema.GroupVersionKind{
					{Kind: "Foo", Version: "v1alpha1"},
					{Kind: "Foo", Version: "v1"},