MatchPolicy          *apiadmissionregistrationv1.MatchPolicyType `json:"matchPolicy,omitempty"`
}

// MatchResourcesApplyConfiguration constructs an declarative configuration of the MatchResources type for use with
// apply.
func MatchResources() *MatchResourcesApplyConfiguration {
	return &MatchResourcesApplyConfiguration{}
}

// WithNamespaceSelector sets the NamespaceSelector field in the declarative configuration to the given value

)

var _ MatchCriteria = &fakeCriteria{}

type fakeCriteria struct {
	matchResources v1.MatchResources
}

func (fc *fakeCriteria) GetMatchResources() v1.MatchResources {
	return fc.matchResources
}

func (fc *fakeCriteria) GetParsedNamespaceSelector() (labels.Selector, error) {
	return metav1.LabelSelectorAsSelector(fc.matchResources.NamespaceSelector)
}

			original: &v1.ValidatingAdmissionPolicyBinding{
				Spec: v1.ValidatingAdmissionPolicyBindingSpec{
					MatchResources: &v1.MatchResources{},
				},
			},
			expected: &v1.ValidatingAdmissionPolicyBinding{
				Spec: v1.ValidatingAdmissionPolicyBindingSpec{
					MatchResources: &v1.MatchResources{
						MatchPolicy:       &equivalent,
						NamespaceSelector: &metav1.LabelSelector{},

	PolicyName        *string                                    `json:"policyName,omitempty"`
	ParamRef          *ParamRefApplyConfiguration                `json:"paramRef,omitempty"`
	MatchResources    *MatchResourcesApplyConfiguration          `json:"matchResources,omitempty"`
	ValidationActions []admissionregistrationv1.ValidationAction `json:"validationActions,omitempty"`
}

	if !matches && matchObjErr == nil {
		return false, schema.GroupVersionResource{}, schema.GroupVersionKind{}, nil
	}

	matchResources := criteria.GetMatchResources()
	matchPolicy := matchResources.MatchPolicy
	if isExcluded, _, _, err := matchesResourceRules(matchResources.ExcludeResourceRules, matchPolicy, attr, o); isExcluded || err != nil {
		return false, schema.GroupVersionResource{}, schema.GroupVersionKind{}, err
	}

	"k8s.io/api/admissionregistration/v1"
	"k8s.io/apimachinery/pkg/types"
)

type PolicyAccessor interface {
	GetName() string
	GetNamespace() string
	GetParamKind() *v1.ParamKind
	GetMatchConstraints() *v1.MatchResources
}

type BindingAccessor interface {
	GetName() string
	GetNamespace() string

	// GetPolicyName returns the name of the (Validating/Mutating)AdmissionPolicy,

	if in.Spec.MatchResources != nil {
		SetDefaults_MatchResources(in.Spec.MatchResources)
		for i := range in.Spec.MatchResources.ResourceRules {
			a := &in.Spec.MatchResources.ResourceRules[i]
			SetDefaults_Rule(&a.RuleWithOperations.Rule)
		}
		for i := range in.Spec.MatchResources.ExcludeResourceRules {
			a := &in.Spec.MatchResources.ExcludeResourceRules[i]

func (c *matcher) BindingMatches(a admission.Attributes, o admission.ObjectInterfaces, binding BindingAccessor) (bool, error) {
	matchResources := binding.GetMatchResources()
	if matchResources == nil {
		return true, nil
	}

	criteria := matchCriteria{constraints: matchResources}
	isMatch, _, _, err := c.Matcher.Matches(a, o, &criteria)
	return isMatch, err
}

	return types.NamespacedName{
		Namespace: "",
		Name:      v.Spec.PolicyName,
	}
}

func (v *validatingAdmissionPolicyBindingAccessor) GetMatchResources() *v1.MatchResources {
	return v.Spec.MatchResources
}

func (v *validatingAdmissionPolicyBindingAccessor) GetParamRef() *v1.ParamRef {
	return v.Spec.ParamRef

	out.ParamRef = (*admissionregistration.ParamRef)(unsafe.Pointer(in.ParamRef))
	if in.MatchResources != nil {
		in, out := &in.MatchResources, &out.MatchResources
		*out = new(admissionregistration.MatchResources)
		if err := Convert_v1_MatchResources_To_admissionregistration_MatchResources(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.MatchResources = nil
	}