diff --git a/plugin/pkg/admission/resourcequota/BUILD b/plugin/pkg/admission/resourcequota/BUILD
index 714cbdd8b02..e638b0691a0 100644
--- a/plugin/pkg/admission/resourcequota/BUILD
+++ b/plugin/pkg/admission/resourcequota/BUILD
@@ -17,19 +17,16 @@ go_library(
     ],
     importpath = "k8s.io/kubernetes/plugin/pkg/admission/resourcequota",
     deps = [
-        "//pkg/apis/core:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset:go_default_library",
-        "//pkg/client/informers/informers_generated/internalversion:go_default_library",
-        "//pkg/client/listers/core/internalversion:go_default_library",
         "//pkg/kubeapiserver/admission:go_default_library",
-        "//pkg/quota:go_default_library",
-        "//pkg/quota/generic:go_default_library",
+        "//pkg/quota/v1:go_default_library",
+        "//pkg/quota/v1/generic:go_default_library",
         "//pkg/util/reflector/prometheus:go_default_library",
         "//pkg/util/workqueue/prometheus:go_default_library",
         "//plugin/pkg/admission/resourcequota/apis/resourcequota:go_default_library",
         "//plugin/pkg/admission/resourcequota/apis/resourcequota/install:go_default_library",
         "//plugin/pkg/admission/resourcequota/apis/resourcequota/v1beta1:go_default_library",
         "//plugin/pkg/admission/resourcequota/apis/resourcequota/validation:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/errors:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/meta:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
@@ -41,7 +38,11 @@ go_library(
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/admission:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/admission/initializer:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/storage/etcd:go_default_library",
+        "//staging/src/k8s.io/client-go/informers:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes:go_default_library",
+        "//staging/src/k8s.io/client-go/listers/core/v1:go_default_library",
         "//staging/src/k8s.io/client-go/util/workqueue:go_default_library",
         "//vendor/github.com/golang/glog:go_default_library",
         "//vendor/github.com/hashicorp/golang-lru:go_default_library",
@@ -54,17 +55,18 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//pkg/apis/core:go_default_library",
-        "//pkg/client/clientset_generated/internalclientset/fake:go_default_library",
-        "//pkg/client/informers/informers_generated/internalversion:go_default_library",
         "//pkg/controller:go_default_library",
-        "//pkg/quota/generic:go_default_library",
-        "//pkg/quota/install:go_default_library",
+        "//pkg/quota/v1/generic:go_default_library",
+        "//pkg/quota/v1/install:go_default_library",
         "//plugin/pkg/admission/resourcequota/apis/resourcequota:go_default_library",
+        "//staging/src/k8s.io/api/core/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/admission:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/client-go/informers:go_default_library",
+        "//staging/src/k8s.io/client-go/kubernetes/fake:go_default_library",
         "//staging/src/k8s.io/client-go/testing:go_default_library",
         "//staging/src/k8s.io/client-go/tools/cache:go_default_library",
         "//vendor/github.com/hashicorp/golang-lru:go_default_library",
diff --git a/plugin/pkg/admission/resourcequota/admission.go b/plugin/pkg/admission/resourcequota/admission.go
index ec8bc590a23..43097ef5569 100644
--- a/plugin/pkg/admission/resourcequota/admission.go
+++ b/plugin/pkg/admission/resourcequota/admission.go
@@ -21,13 +21,14 @@ import (
 	"io"
 	"time"
 
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apiserver/pkg/admission"
-	api "k8s.io/kubernetes/pkg/apis/core"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion"
+	genericadmissioninitializer "k8s.io/apiserver/pkg/admission/initializer"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes"
 	kubeapiserveradmission "k8s.io/kubernetes/pkg/kubeapiserver/admission"
-	"k8s.io/kubernetes/pkg/quota"
-	"k8s.io/kubernetes/pkg/quota/generic"
+	quota "k8s.io/kubernetes/pkg/quota/v1"
+	"k8s.io/kubernetes/pkg/quota/v1/generic"
 	resourcequotaapi "k8s.io/kubernetes/plugin/pkg/admission/resourcequota/apis/resourcequota"
 	"k8s.io/kubernetes/plugin/pkg/admission/resourcequota/apis/resourcequota/validation"
 )
@@ -65,12 +66,13 @@ type QuotaAdmission struct {
 }
 
 var _ admission.ValidationInterface = &QuotaAdmission{}
-var _ = kubeapiserveradmission.WantsInternalKubeClientSet(&QuotaAdmission{})
+var _ = genericadmissioninitializer.WantsExternalKubeInformerFactory(&QuotaAdmission{})
+var _ = genericadmissioninitializer.WantsExternalKubeClientSet(&QuotaAdmission{})
 var _ = kubeapiserveradmission.WantsQuotaConfiguration(&QuotaAdmission{})
 
 type liveLookupEntry struct {
 	expiry time.Time
-	items  []*api.ResourceQuota
+	items  []*corev1.ResourceQuota
 }
 
 // NewResourceQuota configures an admission controller that can enforce quota constraints
@@ -91,12 +93,12 @@ func NewResourceQuota(config *resourcequotaapi.Configuration, numEvaluators int,
 	}, nil
 }
 
-func (a *QuotaAdmission) SetInternalKubeClientSet(client internalclientset.Interface) {
+func (a *QuotaAdmission) SetExternalKubeClientSet(client kubernetes.Interface) {
 	a.quotaAccessor.client = client
 }
 
-func (a *QuotaAdmission) SetInternalKubeInformerFactory(f informers.SharedInformerFactory) {
-	a.quotaAccessor.lister = f.Core().InternalVersion().ResourceQuotas().Lister()
+func (a *QuotaAdmission) SetExternalKubeInformerFactory(f informers.SharedInformerFactory) {
+	a.quotaAccessor.lister = f.Core().V1().ResourceQuotas().Lister()
 }
 
 func (a *QuotaAdmission) SetQuotaConfiguration(c quota.Configuration) {
diff --git a/plugin/pkg/admission/resourcequota/admission_test.go b/plugin/pkg/admission/resourcequota/admission_test.go
index 610b2dec51b..09e29b0b8fc 100644
--- a/plugin/pkg/admission/resourcequota/admission_test.go
+++ b/plugin/pkg/admission/resourcequota/admission_test.go
@@ -25,19 +25,20 @@ import (
 
 	lru "github.com/hashicorp/golang-lru"
 
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apiserver/pkg/admission"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	"k8s.io/client-go/informers"
+	"k8s.io/client-go/kubernetes/fake"
 	testcore "k8s.io/client-go/testing"
 	"k8s.io/client-go/tools/cache"
 	api "k8s.io/kubernetes/pkg/apis/core"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake"
-	informers "k8s.io/kubernetes/pkg/client/informers/informers_generated/internalversion"
 	"k8s.io/kubernetes/pkg/controller"
-	"k8s.io/kubernetes/pkg/quota/generic"
-	"k8s.io/kubernetes/pkg/quota/install"
+	"k8s.io/kubernetes/pkg/quota/v1/generic"
+	"k8s.io/kubernetes/pkg/quota/v1/install"
 	resourcequotaapi "k8s.io/kubernetes/plugin/pkg/admission/resourcequota/apis/resourcequota"
 )
 
@@ -92,33 +93,33 @@ func validPersistentVolumeClaim(name string, resources api.ResourceRequirements)
 }
 
 func TestPrettyPrint(t *testing.T) {
-	toResourceList := func(resources map[api.ResourceName]string) api.ResourceList {
-		resourceList := api.ResourceList{}
+	toResourceList := func(resources map[corev1.ResourceName]string) corev1.ResourceList {
+		resourceList := corev1.ResourceList{}
 		for key, value := range resources {
 			resourceList[key] = resource.MustParse(value)
 		}
 		return resourceList
 	}
 	testCases := []struct {
-		input    api.ResourceList
+		input    corev1.ResourceList
 		expected string
 	}{
 		{
-			input: toResourceList(map[api.ResourceName]string{
-				api.ResourceCPU: "100m",
+			input: toResourceList(map[corev1.ResourceName]string{
+				corev1.ResourceCPU: "100m",
 			}),
 			expected: "cpu=100m",
 		},
 		{
-			input: toResourceList(map[api.ResourceName]string{
-				api.ResourcePods:                   "10",
-				api.ResourceServices:               "10",
-				api.ResourceReplicationControllers: "10",
-				api.ResourceServicesNodePorts:      "10",
-				api.ResourceRequestsCPU:            "100m",
-				api.ResourceRequestsMemory:         "100Mi",
-				api.ResourceLimitsCPU:              "100m",
-				api.ResourceLimitsMemory:           "100Mi",
+			input: toResourceList(map[corev1.ResourceName]string{
+				corev1.ResourcePods:                   "10",
+				corev1.ResourceServices:               "10",
+				corev1.ResourceReplicationControllers: "10",
+				corev1.ResourceServicesNodePorts:      "10",
+				corev1.ResourceRequestsCPU:            "100m",
+				corev1.ResourceRequestsMemory:         "100Mi",
+				corev1.ResourceLimitsCPU:              "100m",
+				corev1.ResourceLimitsMemory:           "100Mi",
 			}),
 			expected: "limits.cpu=100m,limits.memory=100Mi,pods=10,replicationcontrollers=10,requests.cpu=100m,requests.memory=100Mi,services=10,services.nodeports=10",
 		},
@@ -140,7 +141,7 @@ func TestAdmissionIgnoresDelete(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -150,7 +151,7 @@ func TestAdmissionIgnoresDelete(t *testing.T) {
 		evaluator: evaluator,
 	}
 	namespace := "default"
-	err := handler.Validate(admission.NewAttributesRecord(nil, nil, api.Kind("Pod").WithVersion("version"), namespace, "name", api.Resource("pods").WithVersion("version"), "", admission.Delete, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(nil, nil, api.Kind("Pod").WithVersion("version"), namespace, "name", corev1.Resource("pods").WithVersion("version"), "", admission.Delete, false, nil))
 	if err != nil {
 		t.Errorf("ResourceQuota should admit all deletes: %v", err)
 	}
@@ -160,15 +161,15 @@ func TestAdmissionIgnoresDelete(t *testing.T) {
 // It verifies that creation of a pod that would have exceeded quota is properly failed
 // It verifies that create operations to a subresource that would have exceeded quota would succeed
 func TestAdmissionIgnoresSubresources(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{}
+	resourceQuota := &corev1.ResourceQuota{}
 	resourceQuota.Name = "quota"
 	resourceQuota.Namespace = "test"
-	resourceQuota.Status = api.ResourceQuotaStatus{
-		Hard: api.ResourceList{},
-		Used: api.ResourceList{},
+	resourceQuota.Status = corev1.ResourceQuotaStatus{
+		Hard: corev1.ResourceList{},
+		Used: corev1.ResourceList{},
 	}
-	resourceQuota.Status.Hard[api.ResourceMemory] = resource.MustParse("2Gi")
-	resourceQuota.Status.Used[api.ResourceMemory] = resource.MustParse("1Gi")
+	resourceQuota.Status.Hard[corev1.ResourceMemory] = resource.MustParse("2Gi")
+	resourceQuota.Status.Used[corev1.ResourceMemory] = resource.MustParse("1Gi")
 	stopCh := make(chan struct{})
 	defer close(stopCh)
 
@@ -176,7 +177,7 @@ func TestAdmissionIgnoresSubresources(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -185,13 +186,13 @@ func TestAdmissionIgnoresSubresources(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("123", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Errorf("Expected an error because the pod exceeded allowed quota")
 	}
-	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "subresource", admission.Create, false, nil))
+	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "subresource", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Did not expect an error because the action went to a subresource: %v", err)
 	}
@@ -199,18 +200,18 @@ func TestAdmissionIgnoresSubresources(t *testing.T) {
 
 // TestAdmitBelowQuotaLimit verifies that a pod when created has its usage reflected on the quota
 func TestAdmitBelowQuotaLimit(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1"),
-				api.ResourceMemory: resource.MustParse("50Gi"),
-				api.ResourcePods:   resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1"),
+				corev1.ResourceMemory: resource.MustParse("50Gi"),
+				corev1.ResourcePods:   resource.MustParse("3"),
 			},
 		},
 	}
@@ -221,7 +222,7 @@ func TestAdmitBelowQuotaLimit(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -230,9 +231,9 @@ func TestAdmitBelowQuotaLimit(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -253,18 +254,18 @@ func TestAdmitBelowQuotaLimit(t *testing.T) {
 
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1100m"),
-				api.ResourceMemory: resource.MustParse("52Gi"),
-				api.ResourcePods:   resource.MustParse("4"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1100m"),
+				corev1.ResourceMemory: resource.MustParse("52Gi"),
+				corev1.ResourcePods:   resource.MustParse("4"),
 			},
 		},
 	}
@@ -281,18 +282,18 @@ func TestAdmitBelowQuotaLimit(t *testing.T) {
 // TestAdmitDryRun verifies that a pod when created with dry-run doesn not have its usage reflected on the quota
 // and that dry-run requests can still be rejected if they would exceed the quota
 func TestAdmitDryRun(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1"),
-				api.ResourceMemory: resource.MustParse("50Gi"),
-				api.ResourcePods:   resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1"),
+				corev1.ResourceMemory: resource.MustParse("50Gi"),
+				corev1.ResourcePods:   resource.MustParse("3"),
 			},
 		},
 	}
@@ -303,7 +304,7 @@ func TestAdmitDryRun(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -312,16 +313,16 @@ func TestAdmitDryRun(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, true, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, true, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
 
 	newPod = validPod("too-large-pod", 1, getResourceRequirements(getResourceList("100m", "60Gi"), getResourceList("", "")))
-	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, true, nil))
+	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, true, nil))
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -334,18 +335,18 @@ func TestAdmitDryRun(t *testing.T) {
 // TestAdmitHandlesOldObjects verifies that admit handles updates correctly with old objects
 func TestAdmitHandlesOldObjects(t *testing.T) {
 	// in this scenario, the old quota was based on a service type=loadbalancer
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("10"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("10"),
-				api.ResourceServicesNodePorts:     resource.MustParse("10"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("10"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("10"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("1"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("1"),
-				api.ResourceServicesNodePorts:     resource.MustParse("0"),
+			Used: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("1"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("1"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("0"),
 			},
 		},
 	}
@@ -358,7 +359,7 @@ func TestAdmitHandlesOldObjects(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -367,7 +368,7 @@ func TestAdmitHandlesOldObjects(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	// old service was a load balancer, but updated version is a node port.
 	existingService := &api.Service{
@@ -381,7 +382,7 @@ func TestAdmitHandlesOldObjects(t *testing.T) {
 			Ports: []api.ServicePort{{Port: 1234}},
 		},
 	}
-	err := handler.Validate(admission.NewAttributesRecord(newService, existingService, api.Kind("Service").WithVersion("version"), newService.Namespace, newService.Name, api.Resource("services").WithVersion("version"), "", admission.Update, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newService, existingService, api.Kind("Service").WithVersion("version"), newService.Namespace, newService.Name, corev1.Resource("services").WithVersion("version"), "", admission.Update, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -404,21 +405,21 @@ func TestAdmitHandlesOldObjects(t *testing.T) {
 	// verify usage decremented the loadbalancer, and incremented the nodeport, but kept the service the same.
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
 
-	// Verify service usage. Since we don't add negative values, the api.ResourceServicesLoadBalancers
+	// Verify service usage. Since we don't add negative values, the corev1.ResourceServicesLoadBalancers
 	// will remain on last reported value
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("10"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("10"),
-				api.ResourceServicesNodePorts:     resource.MustParse("10"),
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("10"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("10"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("1"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("1"),
-				api.ResourceServicesNodePorts:     resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("1"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("1"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("1"),
 			},
 		},
 	}
@@ -433,16 +434,16 @@ func TestAdmitHandlesOldObjects(t *testing.T) {
 }
 
 func TestAdmitHandlesNegativePVCUpdates(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("3"),
-				api.ResourceRequestsStorage:        resource.MustParse("100Gi"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("3"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("100Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("1"),
-				api.ResourceRequestsStorage:        resource.MustParse("10Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("10Gi"),
 			},
 		},
 	}
@@ -465,7 +466,7 @@ func TestAdmitHandlesNegativePVCUpdates(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -474,7 +475,7 @@ func TestAdmitHandlesNegativePVCUpdates(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	oldPVC := &api.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{Name: "pvc-to-update", Namespace: "test", ResourceVersion: "1"},
@@ -490,7 +491,7 @@ func TestAdmitHandlesNegativePVCUpdates(t *testing.T) {
 		},
 	}
 
-	err = handler.Validate(admission.NewAttributesRecord(newPVC, oldPVC, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPVC.Namespace, newPVC.Name, api.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Update, false, nil))
+	err = handler.Validate(admission.NewAttributesRecord(newPVC, oldPVC, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPVC.Namespace, newPVC.Name, corev1.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Update, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -500,16 +501,16 @@ func TestAdmitHandlesNegativePVCUpdates(t *testing.T) {
 }
 
 func TestAdmitHandlesPVCUpdates(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("3"),
-				api.ResourceRequestsStorage:        resource.MustParse("100Gi"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("3"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("100Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("1"),
-				api.ResourceRequestsStorage:        resource.MustParse("10Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("10Gi"),
 			},
 		},
 	}
@@ -532,7 +533,7 @@ func TestAdmitHandlesPVCUpdates(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -541,7 +542,7 @@ func TestAdmitHandlesPVCUpdates(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	oldPVC := &api.PersistentVolumeClaim{
 		ObjectMeta: metav1.ObjectMeta{Name: "pvc-to-update", Namespace: "test", ResourceVersion: "1"},
@@ -557,7 +558,7 @@ func TestAdmitHandlesPVCUpdates(t *testing.T) {
 		},
 	}
 
-	err = handler.Validate(admission.NewAttributesRecord(newPVC, oldPVC, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPVC.Namespace, newPVC.Name, api.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Update, false, nil))
+	err = handler.Validate(admission.NewAttributesRecord(newPVC, oldPVC, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPVC.Namespace, newPVC.Name, corev1.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Update, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -580,16 +581,16 @@ func TestAdmitHandlesPVCUpdates(t *testing.T) {
 
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("3"),
-				api.ResourceRequestsStorage:        resource.MustParse("100Gi"),
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("3"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("100Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("1"),
-				api.ResourceRequestsStorage:        resource.MustParse("15Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("15Gi"),
 			},
 		},
 	}
@@ -607,18 +608,18 @@ func TestAdmitHandlesPVCUpdates(t *testing.T) {
 // TestAdmitHandlesCreatingUpdates verifies that admit handles updates which behave as creates
 func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 	// in this scenario, there is an existing service
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("10"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("10"),
-				api.ResourceServicesNodePorts:     resource.MustParse("10"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("10"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("10"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("1"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("1"),
-				api.ResourceServicesNodePorts:     resource.MustParse("0"),
+			Used: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("1"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("1"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("0"),
 			},
 		},
 	}
@@ -631,7 +632,7 @@ func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -640,7 +641,7 @@ func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	// old service didn't exist, so this update is actually a create
 	oldService := &api.Service{
@@ -654,7 +655,7 @@ func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 			Ports: []api.ServicePort{{Port: 1234}},
 		},
 	}
-	err := handler.Validate(admission.NewAttributesRecord(newService, oldService, api.Kind("Service").WithVersion("version"), newService.Namespace, newService.Name, api.Resource("services").WithVersion("version"), "", admission.Update, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newService, oldService, api.Kind("Service").WithVersion("version"), newService.Namespace, newService.Name, corev1.Resource("services").WithVersion("version"), "", admission.Update, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -677,18 +678,18 @@ func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 	// verify that the "old" object was ignored for calculating the new usage
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("10"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("10"),
-				api.ResourceServicesNodePorts:     resource.MustParse("10"),
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("10"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("10"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceServices:              resource.MustParse("2"),
-				api.ResourceServicesLoadBalancers: resource.MustParse("1"),
-				api.ResourceServicesNodePorts:     resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourceServices:              resource.MustParse("2"),
+				corev1.ResourceServicesLoadBalancers: resource.MustParse("1"),
+				corev1.ResourceServicesNodePorts:     resource.MustParse("1"),
 			},
 		},
 	}
@@ -704,18 +705,18 @@ func TestAdmitHandlesCreatingUpdates(t *testing.T) {
 
 // TestAdmitExceedQuotaLimit verifies that if a pod exceeded allowed usage that its rejected during admission.
 func TestAdmitExceedQuotaLimit(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1"),
-				api.ResourceMemory: resource.MustParse("50Gi"),
-				api.ResourcePods:   resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1"),
+				corev1.ResourceMemory: resource.MustParse("50Gi"),
+				corev1.ResourcePods:   resource.MustParse("3"),
 			},
 		},
 	}
@@ -726,7 +727,7 @@ func TestAdmitExceedQuotaLimit(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -735,9 +736,9 @@ func TestAdmitExceedQuotaLimit(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Errorf("Expected an error exceeding quota")
 	}
@@ -747,20 +748,20 @@ func TestAdmitExceedQuotaLimit(t *testing.T) {
 // specified on the pod.  In this case, we create a quota that tracks cpu request, memory request, and memory limit.
 // We ensure that a pod that does not specify a memory limit that it fails in admission.
 func TestAdmitEnforceQuotaConstraints(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:          resource.MustParse("3"),
-				api.ResourceMemory:       resource.MustParse("100Gi"),
-				api.ResourceLimitsMemory: resource.MustParse("200Gi"),
-				api.ResourcePods:         resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:          resource.MustParse("3"),
+				corev1.ResourceMemory:       resource.MustParse("100Gi"),
+				corev1.ResourceLimitsMemory: resource.MustParse("200Gi"),
+				corev1.ResourcePods:         resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:          resource.MustParse("1"),
-				api.ResourceMemory:       resource.MustParse("50Gi"),
-				api.ResourceLimitsMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:         resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:          resource.MustParse("1"),
+				corev1.ResourceMemory:       resource.MustParse("50Gi"),
+				corev1.ResourceLimitsMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:         resource.MustParse("3"),
 			},
 		},
 	}
@@ -771,7 +772,7 @@ func TestAdmitEnforceQuotaConstraints(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -780,10 +781,10 @@ func TestAdmitEnforceQuotaConstraints(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	// verify all values are specified as required on the quota
 	newPod := validPod("not-allowed-pod", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("200m", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Errorf("Expected an error because the pod does not specify a memory limit")
 	}
@@ -791,20 +792,20 @@ func TestAdmitEnforceQuotaConstraints(t *testing.T) {
 
 // TestAdmitPodInNamespaceWithoutQuota ensures that if a namespace has no quota, that a pod can get in
 func TestAdmitPodInNamespaceWithoutQuota(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "other", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:          resource.MustParse("3"),
-				api.ResourceMemory:       resource.MustParse("100Gi"),
-				api.ResourceLimitsMemory: resource.MustParse("200Gi"),
-				api.ResourcePods:         resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:          resource.MustParse("3"),
+				corev1.ResourceMemory:       resource.MustParse("100Gi"),
+				corev1.ResourceLimitsMemory: resource.MustParse("200Gi"),
+				corev1.ResourcePods:         resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:          resource.MustParse("1"),
-				api.ResourceMemory:       resource.MustParse("50Gi"),
-				api.ResourceLimitsMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:         resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:          resource.MustParse("1"),
+				corev1.ResourceMemory:       resource.MustParse("50Gi"),
+				corev1.ResourceLimitsMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:         resource.MustParse("3"),
 			},
 		},
 	}
@@ -819,7 +820,7 @@ func TestAdmitPodInNamespaceWithoutQuota(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	quotaAccessor.liveLookupCache = liveLookupCache
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
@@ -830,11 +831,11 @@ func TestAdmitPodInNamespaceWithoutQuota(t *testing.T) {
 		evaluator: evaluator,
 	}
 	// Add to the index
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("not-allowed-pod", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("200m", "")))
 	// Add to the lru cache so we do not do a live client lookup
-	liveLookupCache.Add(newPod.Namespace, liveLookupEntry{expiry: time.Now().Add(time.Duration(30 * time.Second)), items: []*api.ResourceQuota{}})
-	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	liveLookupCache.Add(newPod.Namespace, liveLookupEntry{expiry: time.Now().Add(time.Duration(30 * time.Second)), items: []*corev1.ResourceQuota{}})
+	err = handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Did not expect an error because the pod is in a different namespace than the quota")
 	}
@@ -844,39 +845,39 @@ func TestAdmitPodInNamespaceWithoutQuota(t *testing.T) {
 // It creates a terminating and non-terminating quota, and creates a terminating pod.
 // It ensures that the terminating quota is incremented, and the non-terminating quota is not.
 func TestAdmitBelowTerminatingQuotaLimit(t *testing.T) {
-	resourceQuotaNonTerminating := &api.ResourceQuota{
+	resourceQuotaNonTerminating := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota-non-terminating", Namespace: "test", ResourceVersion: "124"},
-		Spec: api.ResourceQuotaSpec{
-			Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeNotTerminating},
+		Spec: corev1.ResourceQuotaSpec{
+			Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeNotTerminating},
 		},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1"),
-				api.ResourceMemory: resource.MustParse("50Gi"),
-				api.ResourcePods:   resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1"),
+				corev1.ResourceMemory: resource.MustParse("50Gi"),
+				corev1.ResourcePods:   resource.MustParse("3"),
 			},
 		},
 	}
-	resourceQuotaTerminating := &api.ResourceQuota{
+	resourceQuotaTerminating := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota-terminating", Namespace: "test", ResourceVersion: "124"},
-		Spec: api.ResourceQuotaSpec{
-			Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeTerminating},
+		Spec: corev1.ResourceQuotaSpec{
+			Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeTerminating},
 		},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1"),
-				api.ResourceMemory: resource.MustParse("50Gi"),
-				api.ResourcePods:   resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1"),
+				corev1.ResourceMemory: resource.MustParse("50Gi"),
+				corev1.ResourcePods:   resource.MustParse("3"),
 			},
 		},
 	}
@@ -887,7 +888,7 @@ func TestAdmitBelowTerminatingQuotaLimit(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -896,14 +897,14 @@ func TestAdmitBelowTerminatingQuotaLimit(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaNonTerminating)
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaTerminating)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaNonTerminating)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaTerminating)
 
 	// create a pod that has an active deadline
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "2Gi"), getResourceList("", "")))
 	activeDeadlineSeconds := int64(30)
 	newPod.Spec.ActiveDeadlineSeconds = &activeDeadlineSeconds
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -924,24 +925,24 @@ func TestAdmitBelowTerminatingQuotaLimit(t *testing.T) {
 
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
 
 	// ensure only the quota-terminating was updated
 	if usage.Name != resourceQuotaTerminating.Name {
 		t.Errorf("Incremented the wrong quota, expected %v, actual %v", resourceQuotaTerminating.Name, usage.Name)
 	}
 
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("3"),
-				api.ResourceMemory: resource.MustParse("100Gi"),
-				api.ResourcePods:   resource.MustParse("5"),
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("3"),
+				corev1.ResourceMemory: resource.MustParse("100Gi"),
+				corev1.ResourcePods:   resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourceCPU:    resource.MustParse("1100m"),
-				api.ResourceMemory: resource.MustParse("52Gi"),
-				api.ResourcePods:   resource.MustParse("4"),
+			Used: corev1.ResourceList{
+				corev1.ResourceCPU:    resource.MustParse("1100m"),
+				corev1.ResourceMemory: resource.MustParse("52Gi"),
+				corev1.ResourcePods:   resource.MustParse("4"),
 			},
 		},
 	}
@@ -958,31 +959,31 @@ func TestAdmitBelowTerminatingQuotaLimit(t *testing.T) {
 // TestAdmitBelowBestEffortQuotaLimit creates a best effort and non-best effort quota.
 // It verifies that best effort pods are properly scoped to the best effort quota document.
 func TestAdmitBelowBestEffortQuotaLimit(t *testing.T) {
-	resourceQuotaBestEffort := &api.ResourceQuota{
+	resourceQuotaBestEffort := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota-besteffort", Namespace: "test", ResourceVersion: "124"},
-		Spec: api.ResourceQuotaSpec{
-			Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeBestEffort},
+		Spec: corev1.ResourceQuotaSpec{
+			Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeBestEffort},
 		},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePods: resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePods: resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("3"),
 			},
 		},
 	}
-	resourceQuotaNotBestEffort := &api.ResourceQuota{
+	resourceQuotaNotBestEffort := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota-not-besteffort", Namespace: "test", ResourceVersion: "124"},
-		Spec: api.ResourceQuotaSpec{
-			Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeNotBestEffort},
+		Spec: corev1.ResourceQuotaSpec{
+			Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeNotBestEffort},
 		},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePods: resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePods: resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("3"),
 			},
 		},
 	}
@@ -993,7 +994,7 @@ func TestAdmitBelowBestEffortQuotaLimit(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -1002,12 +1003,12 @@ func TestAdmitBelowBestEffortQuotaLimit(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaBestEffort)
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaNotBestEffort)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaBestEffort)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuotaNotBestEffort)
 
 	// create a pod that is best effort because it does not make a request for anything
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -1023,19 +1024,19 @@ func TestAdmitBelowBestEffortQuotaLimit(t *testing.T) {
 	}
 	decimatedActions := removeListWatch(kubeClient.Actions())
 	lastActionIndex := len(decimatedActions) - 1
-	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*api.ResourceQuota)
+	usage := decimatedActions[lastActionIndex].(testcore.UpdateAction).GetObject().(*corev1.ResourceQuota)
 
 	if usage.Name != resourceQuotaBestEffort.Name {
 		t.Errorf("Incremented the wrong quota, expected %v, actual %v", resourceQuotaBestEffort.Name, usage.Name)
 	}
 
-	expectedUsage := api.ResourceQuota{
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePods: resource.MustParse("5"),
+	expectedUsage := corev1.ResourceQuota{
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePods: resource.MustParse("4"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("4"),
 			},
 		},
 	}
@@ -1065,17 +1066,17 @@ func removeListWatch(in []testcore.Action) []testcore.Action {
 // TestAdmitBestEffortQuotaLimitIgnoresBurstable validates that a besteffort quota does not match a resource
 // guaranteed pod.
 func TestAdmitBestEffortQuotaLimitIgnoresBurstable(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota-besteffort", Namespace: "test", ResourceVersion: "124"},
-		Spec: api.ResourceQuotaSpec{
-			Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeBestEffort},
+		Spec: corev1.ResourceQuotaSpec{
+			Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeBestEffort},
 		},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePods: resource.MustParse("5"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("5"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePods: resource.MustParse("3"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("3"),
 			},
 		},
 	}
@@ -1086,7 +1087,7 @@ func TestAdmitBestEffortQuotaLimitIgnoresBurstable(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -1095,9 +1096,9 @@ func TestAdmitBestEffortQuotaLimitIgnoresBurstable(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "1Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -1110,32 +1111,32 @@ func TestAdmitBestEffortQuotaLimitIgnoresBurstable(t *testing.T) {
 
 func TestHasUsageStats(t *testing.T) {
 	testCases := map[string]struct {
-		a        api.ResourceQuota
+		a        corev1.ResourceQuota
 		expected bool
 	}{
 		"empty": {
-			a:        api.ResourceQuota{Status: api.ResourceQuotaStatus{Hard: api.ResourceList{}}},
+			a:        corev1.ResourceQuota{Status: corev1.ResourceQuotaStatus{Hard: corev1.ResourceList{}}},
 			expected: true,
 		},
 		"hard-only": {
-			a: api.ResourceQuota{
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourceMemory: resource.MustParse("1Gi"),
+			a: corev1.ResourceQuota{
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourceMemory: resource.MustParse("1Gi"),
 					},
-					Used: api.ResourceList{},
+					Used: corev1.ResourceList{},
 				},
 			},
 			expected: false,
 		},
 		"hard-used": {
-			a: api.ResourceQuota{
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourceMemory: resource.MustParse("1Gi"),
+			a: corev1.ResourceQuota{
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourceMemory: resource.MustParse("1Gi"),
 					},
-					Used: api.ResourceList{
-						api.ResourceMemory: resource.MustParse("500Mi"),
+					Used: corev1.ResourceList{
+						corev1.ResourceMemory: resource.MustParse("500Mi"),
 					},
 				},
 			},
@@ -1153,14 +1154,14 @@ func TestHasUsageStats(t *testing.T) {
 // namespace, it will be set.
 func TestAdmissionSetsMissingNamespace(t *testing.T) {
 	namespace := "test"
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: namespace, ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePods: resource.MustParse("3"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("3"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePods: resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePods: resource.MustParse("1"),
 			},
 		},
 	}
@@ -1172,7 +1173,7 @@ func TestAdmissionSetsMissingNamespace(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -1181,13 +1182,13 @@ func TestAdmissionSetsMissingNamespace(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	newPod := validPod("pod-without-namespace", 1, getResourceRequirements(getResourceList("1", "2Gi"), getResourceList("", "")))
 
 	// unset the namespace
 	newPod.ObjectMeta.Namespace = ""
 
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Got unexpected error: %v", err)
 	}
@@ -1198,16 +1199,16 @@ func TestAdmissionSetsMissingNamespace(t *testing.T) {
 
 // TestAdmitRejectsNegativeUsage verifies that usage for any measured resource cannot be negative.
 func TestAdmitRejectsNegativeUsage(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("3"),
-				api.ResourceRequestsStorage:        resource.MustParse("100Gi"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("3"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("100Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourcePersistentVolumeClaims: resource.MustParse("1"),
-				api.ResourceRequestsStorage:        resource.MustParse("10Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"),
+				corev1.ResourceRequestsStorage:        resource.MustParse("10Gi"),
 			},
 		},
 	}
@@ -1218,7 +1219,7 @@ func TestAdmitRejectsNegativeUsage(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -1227,17 +1228,17 @@ func TestAdmitRejectsNegativeUsage(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 	// verify quota rejects negative pvc storage requests
 	newPvc := validPersistentVolumeClaim("not-allowed-pvc", getResourceRequirements(api.ResourceList{api.ResourceStorage: resource.MustParse("-1Gi")}, api.ResourceList{}))
-	err := handler.Validate(admission.NewAttributesRecord(newPvc, nil, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPvc.Namespace, newPvc.Name, api.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPvc, nil, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPvc.Namespace, newPvc.Name, corev1.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Errorf("Expected an error because the pvc has negative storage usage")
 	}
 
 	// verify quota accepts non-negative pvc storage requests
 	newPvc = validPersistentVolumeClaim("not-allowed-pvc", getResourceRequirements(api.ResourceList{api.ResourceStorage: resource.MustParse("1Gi")}, api.ResourceList{}))
-	err = handler.Validate(admission.NewAttributesRecord(newPvc, nil, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPvc.Namespace, newPvc.Name, api.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Create, false, nil))
+	err = handler.Validate(admission.NewAttributesRecord(newPvc, nil, api.Kind("PersistentVolumeClaim").WithVersion("version"), newPvc.Namespace, newPvc.Name, corev1.Resource("persistentvolumeclaims").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -1245,16 +1246,16 @@ func TestAdmitRejectsNegativeUsage(t *testing.T) {
 
 // TestAdmitWhenUnrelatedResourceExceedsQuota verifies that if resource X exceeds quota, it does not prohibit resource Y from admission.
 func TestAdmitWhenUnrelatedResourceExceedsQuota(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceServices: resource.MustParse("3"),
-				api.ResourcePods:     resource.MustParse("4"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceServices: resource.MustParse("3"),
+				corev1.ResourcePods:     resource.MustParse("4"),
 			},
-			Used: api.ResourceList{
-				api.ResourceServices: resource.MustParse("4"),
-				api.ResourcePods:     resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourceServices: resource.MustParse("4"),
+				corev1.ResourcePods:     resource.MustParse("1"),
 			},
 		},
 	}
@@ -1265,7 +1266,7 @@ func TestAdmitWhenUnrelatedResourceExceedsQuota(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 	config := &resourcequotaapi.Configuration{}
 	quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 	evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -1274,11 +1275,11 @@ func TestAdmitWhenUnrelatedResourceExceedsQuota(t *testing.T) {
 		Handler:   admission.NewHandler(admission.Create, admission.Update),
 		evaluator: evaluator,
 	}
-	informerFactory.Core().InternalVersion().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
+	informerFactory.Core().V1().ResourceQuotas().Informer().GetIndexer().Add(resourceQuota)
 
 	// create a pod that should pass existing quota
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
@@ -1293,7 +1294,7 @@ func TestAdmitLimitedResourceNoQuota(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 	// disable consumption of cpu unless there is a covering quota.
 	config := &resourcequotaapi.Configuration{
@@ -1312,7 +1313,7 @@ func TestAdmitLimitedResourceNoQuota(t *testing.T) {
 		evaluator: evaluator,
 	}
 	newPod := validPod("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Errorf("Expected an error for consuming a limited resource without quota.")
 	}
@@ -1327,7 +1328,7 @@ func TestAdmitLimitedResourceNoQuotaIgnoresNonMatchingResources(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 	// disable consumption of cpu unless there is a covering quota.
 	config := &resourcequotaapi.Configuration{
@@ -1346,7 +1347,7 @@ func TestAdmitLimitedResourceNoQuotaIgnoresNonMatchingResources(t *testing.T) {
 		evaluator: evaluator,
 	}
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Fatalf("Unexpected error: %v", err)
 	}
@@ -1354,14 +1355,14 @@ func TestAdmitLimitedResourceNoQuotaIgnoresNonMatchingResources(t *testing.T) {
 
 // TestAdmitLimitedResourceWithQuota verifies if a limited resource is configured with quota, it can be consumed.
 func TestAdmitLimitedResourceWithQuota(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceRequestsCPU: resource.MustParse("10"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceRequestsCPU: resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceRequestsCPU: resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourceRequestsCPU: resource.MustParse("1"),
 			},
 		},
 	}
@@ -1373,7 +1374,7 @@ func TestAdmitLimitedResourceWithQuota(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 	// disable consumption of cpu unless there is a covering quota.
 	// disable consumption of cpu unless there is a covering quota.
@@ -1394,7 +1395,7 @@ func TestAdmitLimitedResourceWithQuota(t *testing.T) {
 	}
 	indexer.Add(resourceQuota)
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -1402,25 +1403,25 @@ func TestAdmitLimitedResourceWithQuota(t *testing.T) {
 
 // TestAdmitLimitedResourceWithMultipleQuota verifies if a limited resource is configured with quota, it can be consumed if one matches.
 func TestAdmitLimitedResourceWithMultipleQuota(t *testing.T) {
-	resourceQuota1 := &api.ResourceQuota{
+	resourceQuota1 := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota1", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceRequestsCPU: resource.MustParse("10"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceRequestsCPU: resource.MustParse("10"),
 			},
-			Used: api.ResourceList{
-				api.ResourceRequestsCPU: resource.MustParse("1"),
+			Used: corev1.ResourceList{
+				corev1.ResourceRequestsCPU: resource.MustParse("1"),
 			},
 		},
 	}
-	resourceQuota2 := &api.ResourceQuota{
+	resourceQuota2 := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota2", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceMemory: resource.MustParse("10Gi"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceMemory: resource.MustParse("10Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourceMemory: resource.MustParse("1Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourceMemory: resource.MustParse("1Gi"),
 			},
 		},
 	}
@@ -1432,7 +1433,7 @@ func TestAdmitLimitedResourceWithMultipleQuota(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 	// disable consumption of cpu unless there is a covering quota.
 	// disable consumption of cpu unless there is a covering quota.
@@ -1454,7 +1455,7 @@ func TestAdmitLimitedResourceWithMultipleQuota(t *testing.T) {
 	indexer.Add(resourceQuota1)
 	indexer.Add(resourceQuota2)
 	newPod := validPod("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -1462,14 +1463,14 @@ func TestAdmitLimitedResourceWithMultipleQuota(t *testing.T) {
 
 // TestAdmitLimitedResourceWithQuotaThatDoesNotCover verifies if a limited resource is configured the quota must cover the resource.
 func TestAdmitLimitedResourceWithQuotaThatDoesNotCover(t *testing.T) {
-	resourceQuota := &api.ResourceQuota{
+	resourceQuota := &corev1.ResourceQuota{
 		ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-		Status: api.ResourceQuotaStatus{
-			Hard: api.ResourceList{
-				api.ResourceMemory: resource.MustParse("10Gi"),
+		Status: corev1.ResourceQuotaStatus{
+			Hard: corev1.ResourceList{
+				corev1.ResourceMemory: resource.MustParse("10Gi"),
 			},
-			Used: api.ResourceList{
-				api.ResourceMemory: resource.MustParse("1Gi"),
+			Used: corev1.ResourceList{
+				corev1.ResourceMemory: resource.MustParse("1Gi"),
 			},
 		},
 	}
@@ -1481,7 +1482,7 @@ func TestAdmitLimitedResourceWithQuotaThatDoesNotCover(t *testing.T) {
 	informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 	quotaAccessor, _ := newQuotaAccessor()
 	quotaAccessor.client = kubeClient
-	quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+	quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 	// disable consumption of cpu unless there is a covering quota.
 	// disable consumption of cpu unless there is a covering quota.
@@ -1502,7 +1503,7 @@ func TestAdmitLimitedResourceWithQuotaThatDoesNotCover(t *testing.T) {
 	}
 	indexer.Add(resourceQuota)
 	newPod := validPod("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")))
-	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+	err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 	if err == nil {
 		t.Fatalf("Expected an error since the quota did not cover cpu")
 	}
@@ -1513,22 +1514,22 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 	testCases := []struct {
 		description  string
 		testPod      *api.Pod
-		quota        *api.ResourceQuota
-		anotherQuota *api.ResourceQuota
+		quota        *corev1.ResourceQuota
+		anotherQuota *corev1.ResourceQuota
 		config       *resourcequotaapi.Configuration
 		expErr       string
 	}{
 		{
 			description: "Covering quota exists for configured limited scope PriorityClassNameExists.",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "fake-priority"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists},
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists},
 						},
 					},
 				},
@@ -1537,10 +1538,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
@@ -1551,14 +1552,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "configured limited scope PriorityClassNameExists and limited cpu resource. No covering quota for cpu and pod admit fails.",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "fake-priority"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists},
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists},
 						},
 					},
 				},
@@ -1567,10 +1568,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 						MatchContains: []string{"requests.cpu"}, // match on "requests.cpu" only
@@ -1582,15 +1583,15 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Covering quota does not exist for configured limited scope PriorityClassNameExists.",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "fake-priority"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
@@ -1601,15 +1602,15 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Covering quota does not exist for configured limited scope resourceQuotaBestEffort",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "fake-priority"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
@@ -1620,17 +1621,17 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Covering quota exist for configured limited scope resourceQuotaBestEffort",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "fake-priority"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota-besteffort", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeBestEffort},
+				Spec: corev1.ResourceQuotaSpec{
+					Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeBestEffort},
 				},
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourcePods: resource.MustParse("5"),
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("5"),
 					},
-					Used: api.ResourceList{
-						api.ResourcePods: resource.MustParse("3"),
+					Used: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("3"),
 					},
 				},
 			},
@@ -1638,10 +1639,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
@@ -1652,24 +1653,24 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Neither matches pod. Pod allowed",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "1Gi"), getResourceList("", "")), "fake-priority"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1681,24 +1682,24 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Only BestEffort scope matches pod. Pod admit fails because covering quota is missing for BestEffort scope",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "fake-priority"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1710,24 +1711,24 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Only PriorityClass scope matches pod. Pod admit fails because covering quota is missing for PriorityClass scope",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("100m", "1Gi"), getResourceList("", "")), "cluster-services"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1739,24 +1740,24 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Both the scopes matches pod. Pod admit fails because covering quota is missing for PriorityClass scope and BestEffort scope",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "cluster-services"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1768,17 +1769,17 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Both the scopes matches pod. Quota available only for BestEffort scope. Pod admit fails because covering quota is missing for PriorityClass scope",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota-besteffort", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeBestEffort},
+				Spec: corev1.ResourceQuotaSpec{
+					Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeBestEffort},
 				},
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourcePods: resource.MustParse("5"),
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("5"),
 					},
-					Used: api.ResourceList{
-						api.ResourcePods: resource.MustParse("3"),
+					Used: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("3"),
 					},
 				},
 			},
@@ -1786,19 +1787,19 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1810,14 +1811,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Both the scopes matches pod. Quota available only for PriorityClass scope. Pod admit fails because covering quota is missing for BestEffort scope",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1828,19 +1829,19 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1852,28 +1853,28 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Two scopes,BestEffort and PriorityClassIN, in two LimitedResources. Both the scopes matches pod. Quota available only for both the scopes. Pod admit success. No Error",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("", ""), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota-besteffort", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					Scopes: []api.ResourceQuotaScope{api.ResourceQuotaScopeBestEffort},
+				Spec: corev1.ResourceQuotaSpec{
+					Scopes: []corev1.ResourceQuotaScope{corev1.ResourceQuotaScopeBestEffort},
 				},
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourcePods: resource.MustParse("5"),
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("5"),
 					},
-					Used: api.ResourceList{
-						api.ResourcePods: resource.MustParse("3"),
+					Used: corev1.ResourceList{
+						corev1.ResourcePods: resource.MustParse("3"),
 					},
 				},
 			},
-			anotherQuota: &api.ResourceQuota{
+			anotherQuota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1884,19 +1885,19 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopeBestEffort,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopeBestEffort,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1908,30 +1909,30 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod allowed with priorityclass if limited scope PriorityClassNameExists not configured.",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "fake-priority"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config:      &resourcequotaapi.Configuration{},
 			expErr:      "",
 		},
 		{
 			description: "quota fails, though covering quota for configured limited scope PriorityClassNameExists exists.",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "20Gi"), getResourceList("", "")), "fake-priority"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists},
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists},
 						},
 					},
 				},
-				Status: api.ResourceQuotaStatus{
-					Hard: api.ResourceList{
-						api.ResourceMemory: resource.MustParse("10Gi"),
+				Status: corev1.ResourceQuotaStatus{
+					Hard: corev1.ResourceList{
+						corev1.ResourceMemory: resource.MustParse("10Gi"),
 					},
-					Used: api.ResourceList{
-						api.ResourceMemory: resource.MustParse("1Gi"),
+					Used: corev1.ResourceList{
+						corev1.ResourceMemory: resource.MustParse("1Gi"),
 					},
 				},
 			},
@@ -1939,10 +1940,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists,
 							},
 						},
 					},
@@ -1953,14 +1954,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod has different priorityclass than configured limited. Covering quota exists for configured limited scope PriorityClassIn.",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "fake-priority"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1971,10 +1972,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -1986,14 +1987,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod has limited priorityclass. Covering quota exists for configured limited scope PriorityClassIn.",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"cluster-services"},
 							},
 						},
@@ -2004,10 +2005,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name", "cluster-services"},
 							},
 						},
@@ -2019,14 +2020,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod has limited priorityclass. Covering quota  does not exist for configured limited scope PriorityClassIn.",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name"},
 							},
 						},
@@ -2037,10 +2038,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name", "cluster-services"},
 							},
 						},
@@ -2052,14 +2053,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "From the above test case, just changing pod priority from cluster-services to another-priorityclass-name. expecting no error",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "another-priorityclass-name"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name"},
 							},
 						},
@@ -2070,10 +2071,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name", "cluster-services"},
 							},
 						},
@@ -2085,15 +2086,15 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod has limited priorityclass. Covering quota does NOT exists for configured limited scope PriorityClassIn.",
 			testPod:     validPodWithPriority("not-allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "cluster-services"),
-			quota:       &api.ResourceQuota{},
+			quota:       &corev1.ResourceQuota{},
 			config: &resourcequotaapi.Configuration{
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name", "cluster-services"},
 							},
 						},
@@ -2105,14 +2106,14 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		{
 			description: "Pod has limited priorityclass. Covering quota exists for configured limited scope PriorityClassIn through PriorityClassNameExists",
 			testPod:     validPodWithPriority("allowed-pod", 1, getResourceRequirements(getResourceList("3", "2Gi"), getResourceList("", "")), "cluster-services"),
-			quota: &api.ResourceQuota{
+			quota: &corev1.ResourceQuota{
 				ObjectMeta: metav1.ObjectMeta{Name: "quota", Namespace: "test", ResourceVersion: "124"},
-				Spec: api.ResourceQuotaSpec{
-					ScopeSelector: &api.ScopeSelector{
-						MatchExpressions: []api.ScopedResourceSelectorRequirement{
+				Spec: corev1.ResourceQuotaSpec{
+					ScopeSelector: &corev1.ScopeSelector{
+						MatchExpressions: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpExists},
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpExists},
 						},
 					},
 				},
@@ -2121,10 +2122,10 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 				LimitedResources: []resourcequotaapi.LimitedResource{
 					{
 						Resource: "pods",
-						MatchScopes: []api.ScopedResourceSelectorRequirement{
+						MatchScopes: []corev1.ScopedResourceSelectorRequirement{
 							{
-								ScopeName: api.ResourceQuotaScopePriorityClass,
-								Operator:  api.ScopeSelectorOpIn,
+								ScopeName: corev1.ResourceQuotaScopePriorityClass,
+								Operator:  corev1.ScopeSelectorOpIn,
 								Values:    []string{"another-priorityclass-name", "cluster-services"},
 							},
 						},
@@ -2150,7 +2151,7 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		informerFactory := informers.NewSharedInformerFactory(kubeClient, controller.NoResyncPeriodFunc())
 		quotaAccessor, _ := newQuotaAccessor()
 		quotaAccessor.client = kubeClient
-		quotaAccessor.lister = informerFactory.Core().InternalVersion().ResourceQuotas().Lister()
+		quotaAccessor.lister = informerFactory.Core().V1().ResourceQuotas().Lister()
 
 		quotaConfiguration := install.NewQuotaConfigurationForAdmission()
 		evaluator := NewQuotaEvaluator(quotaAccessor, quotaConfiguration.IgnoredResources(), generic.NewRegistry(quotaConfiguration.Evaluators()), nil, config, 5, stopCh)
@@ -2163,7 +2164,7 @@ func TestAdmitLimitedScopeWithCoverQuota(t *testing.T) {
 		if testCase.anotherQuota != nil {
 			indexer.Add(testCase.anotherQuota)
 		}
-		err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, api.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
+		err := handler.Validate(admission.NewAttributesRecord(newPod, nil, api.Kind("Pod").WithVersion("version"), newPod.Namespace, newPod.Name, corev1.Resource("pods").WithVersion("version"), "", admission.Create, false, nil))
 		if testCase.expErr == "" {
 			if err != nil {
 				t.Fatalf("Testcase, %v, failed with unexpected error: %v. ExpErr: %v", testCase.description, err, testCase.expErr)
diff --git a/plugin/pkg/admission/resourcequota/controller.go b/plugin/pkg/admission/resourcequota/controller.go
index 30b9defafa0..34c621903b9 100644
--- a/plugin/pkg/admission/resourcequota/controller.go
+++ b/plugin/pkg/admission/resourcequota/controller.go
@@ -25,6 +25,7 @@ import (
 
 	"github.com/golang/glog"
 
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -34,9 +35,8 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/apiserver/pkg/admission"
 	"k8s.io/client-go/util/workqueue"
-	api "k8s.io/kubernetes/pkg/apis/core"
-	"k8s.io/kubernetes/pkg/quota"
-	"k8s.io/kubernetes/pkg/quota/generic"
+	quota "k8s.io/kubernetes/pkg/quota/v1"
+	"k8s.io/kubernetes/pkg/quota/v1/generic"
 	_ "k8s.io/kubernetes/pkg/util/reflector/prometheus" // for reflector metric registration
 	_ "k8s.io/kubernetes/pkg/util/workqueue/prometheus" // for workqueue metric registration
 	resourcequotaapi "k8s.io/kubernetes/plugin/pkg/admission/resourcequota/apis/resourcequota"
@@ -52,7 +52,7 @@ type Evaluator interface {
 type quotaEvaluator struct {
 	quotaAccessor QuotaAccessor
 	// lockAcquisitionFunc acquires any required locks and returns a cleanup method to defer
-	lockAcquisitionFunc func([]api.ResourceQuota) func()
+	lockAcquisitionFunc func([]corev1.ResourceQuota) func()
 
 	ignoredResources map[schema.GroupResource]struct{}
 
@@ -111,7 +111,7 @@ func newAdmissionWaiter(a admission.Attributes) *admissionWaiter {
 // NewQuotaEvaluator configures an admission controller that can enforce quota constraints
 // using the provided registry.  The registry must have the capability to handle group/kinds that
 // are persisted by the server this admission controller is intercepting
-func NewQuotaEvaluator(quotaAccessor QuotaAccessor, ignoredResources map[schema.GroupResource]struct{}, quotaRegistry quota.Registry, lockAcquisitionFunc func([]api.ResourceQuota) func(), config *resourcequotaapi.Configuration, workers int, stopCh <-chan struct{}) Evaluator {
+func NewQuotaEvaluator(quotaAccessor QuotaAccessor, ignoredResources map[schema.GroupResource]struct{}, quotaRegistry quota.Registry, lockAcquisitionFunc func([]corev1.ResourceQuota) func(), config *resourcequotaapi.Configuration, workers int, stopCh <-chan struct{}) Evaluator {
 	// if we get a nil config, just create an empty default.
 	if config == nil {
 		config = &resourcequotaapi.Configuration{}
@@ -214,7 +214,7 @@ func (e *quotaEvaluator) checkAttributes(ns string, admissionAttributes []*admis
 //    updates failed on conflict errors and we have retries left, re-get the failed quota from our cache for the latest version
 //    and recurse into this method with the subset.  It's safe for us to evaluate ONLY the subset, because the other quota
 //    documents for these waiters have already been evaluated.  Step 1, will mark all the ones that should already have succeeded.
-func (e *quotaEvaluator) checkQuotas(quotas []api.ResourceQuota, admissionAttributes []*admissionWaiter, remainingRetries int) {
+func (e *quotaEvaluator) checkQuotas(quotas []corev1.ResourceQuota, admissionAttributes []*admissionWaiter, remainingRetries int) {
 	// yet another copy to compare against originals to see if we actually have deltas
 	originalQuotas, err := copyQuotas(quotas)
 	if err != nil {
@@ -264,7 +264,7 @@ func (e *quotaEvaluator) checkQuotas(quotas []api.ResourceQuota, admissionAttrib
 	// 1. check to see if the quota changed.  If not, skip.
 	// 2. if the quota changed and the update passes, be happy
 	// 3. if the quota changed and the update fails, add the original to a retry list
-	var updatedFailedQuotas []api.ResourceQuota
+	var updatedFailedQuotas []corev1.ResourceQuota
 	var lastErr error
 	for i := range quotas {
 		newQuota := quotas[i]
@@ -318,7 +318,7 @@ func (e *quotaEvaluator) checkQuotas(quotas []api.ResourceQuota, admissionAttrib
 
 	// this logic goes through our cache to find the new version of all quotas that failed update.  If something has been removed
 	// it is skipped on this retry.  After all, you removed it.
-	quotasToCheck := []api.ResourceQuota{}
+	quotasToCheck := []corev1.ResourceQuota{}
 	for _, newQuota := range newQuotas {
 		for _, oldQuota := range updatedFailedQuotas {
 			if newQuota.Name == oldQuota.Name {
@@ -330,8 +330,8 @@ func (e *quotaEvaluator) checkQuotas(quotas []api.ResourceQuota, admissionAttrib
 	e.checkQuotas(quotasToCheck, admissionAttributes, remainingRetries-1)
 }
 
-func copyQuotas(in []api.ResourceQuota) ([]api.ResourceQuota, error) {
-	out := make([]api.ResourceQuota, 0, len(in))
+func copyQuotas(in []corev1.ResourceQuota) ([]corev1.ResourceQuota, error) {
+	out := make([]corev1.ResourceQuota, 0, len(in))
 	for _, quota := range in {
 		out = append(out, *quota.DeepCopy())
 	}
@@ -355,8 +355,8 @@ func filterLimitedResourcesByGroupResource(input []resourcequotaapi.LimitedResou
 // limitedByDefault determines from the specified usage and limitedResources the set of resources names
 // that must be present in a covering quota.  It returns empty set if it was unable to determine if
 // a resource was not limited by default.
-func limitedByDefault(usage api.ResourceList, limitedResources []resourcequotaapi.LimitedResource) []api.ResourceName {
-	result := []api.ResourceName{}
+func limitedByDefault(usage corev1.ResourceList, limitedResources []resourcequotaapi.LimitedResource) []corev1.ResourceName {
+	result := []corev1.ResourceName{}
 	for _, limitedResource := range limitedResources {
 		for k, v := range usage {
 			// if a resource is consumed, we need to check if it matches on the limited resource list.
@@ -374,13 +374,13 @@ func limitedByDefault(usage api.ResourceList, limitedResources []resourcequotaap
 	return result
 }
 
-func getMatchedLimitedScopes(evaluator quota.Evaluator, inputObject runtime.Object, limitedResources []resourcequotaapi.LimitedResource) ([]api.ScopedResourceSelectorRequirement, error) {
-	scopes := []api.ScopedResourceSelectorRequirement{}
+func getMatchedLimitedScopes(evaluator quota.Evaluator, inputObject runtime.Object, limitedResources []resourcequotaapi.LimitedResource) ([]corev1.ScopedResourceSelectorRequirement, error) {
+	scopes := []corev1.ScopedResourceSelectorRequirement{}
 	for _, limitedResource := range limitedResources {
 		matched, err := evaluator.MatchingScopes(inputObject, limitedResource.MatchScopes)
 		if err != nil {
 			glog.Errorf("Error while matching limited Scopes: %v", err)
-			return []api.ScopedResourceSelectorRequirement{}, err
+			return []corev1.ScopedResourceSelectorRequirement{}, err
 		}
 		for _, scope := range matched {
 			scopes = append(scopes, scope)
@@ -391,7 +391,7 @@ func getMatchedLimitedScopes(evaluator quota.Evaluator, inputObject runtime.Obje
 
 // checkRequest verifies that the request does not exceed any quota constraint. it returns a copy of quotas not yet persisted
 // that capture what the usage would be if the request succeeded.  It return an error if there is insufficient quota to satisfy the request
-func (e *quotaEvaluator) checkRequest(quotas []api.ResourceQuota, a admission.Attributes) ([]api.ResourceQuota, error) {
+func (e *quotaEvaluator) checkRequest(quotas []corev1.ResourceQuota, a admission.Attributes) ([]corev1.ResourceQuota, error) {
 	evaluator := e.registry.Get(a.GetResource().GroupResource())
 	if evaluator == nil {
 		return quotas, nil
@@ -400,8 +400,8 @@ func (e *quotaEvaluator) checkRequest(quotas []api.ResourceQuota, a admission.At
 }
 
 // CheckRequest is a static version of quotaEvaluator.checkRequest, possible to be called from outside.
-func CheckRequest(quotas []api.ResourceQuota, a admission.Attributes, evaluator quota.Evaluator,
-	limited []resourcequotaapi.LimitedResource) ([]api.ResourceQuota, error) {
+func CheckRequest(quotas []corev1.ResourceQuota, a admission.Attributes, evaluator quota.Evaluator,
+	limited []resourcequotaapi.LimitedResource) ([]corev1.ResourceQuota, error) {
 	if !evaluator.Handles(a) {
 		return quotas, nil
 	}
@@ -416,7 +416,7 @@ func CheckRequest(quotas []api.ResourceQuota, a admission.Attributes, evaluator
 	}
 
 	// determine the set of resource names that must exist in a covering quota
-	limitedResourceNames := []api.ResourceName{}
+	limitedResourceNames := []corev1.ResourceName{}
 	limitedResources := filterLimitedResourcesByGroupResource(limited, a.GetResource().GroupResource())
 	if len(limitedResources) > 0 {
 		deltaUsage, err := evaluator.Usage(inputObject)
@@ -436,7 +436,7 @@ func CheckRequest(quotas []api.ResourceQuota, a admission.Attributes, evaluator
 	// this is needed to know if we have satisfied any constraints where consumption
 	// was limited by default.
 	restrictedResourcesSet := sets.String{}
-	restrictedScopes := []api.ScopedResourceSelectorRequirement{}
+	restrictedScopes := []corev1.ScopedResourceSelectorRequirement{}
 	for i := range quotas {
 		resourceQuota := quotas[i]
 		scopeSelectors := getScopeSelectorsFromQuota(resourceQuota)
@@ -571,12 +571,12 @@ func CheckRequest(quotas []api.ResourceQuota, a admission.Attributes, evaluator
 	return outQuotas, nil
 }
 
-func getScopeSelectorsFromQuota(quota api.ResourceQuota) []api.ScopedResourceSelectorRequirement {
-	selectors := []api.ScopedResourceSelectorRequirement{}
+func getScopeSelectorsFromQuota(quota corev1.ResourceQuota) []corev1.ScopedResourceSelectorRequirement {
+	selectors := []corev1.ScopedResourceSelectorRequirement{}
 	for _, scope := range quota.Spec.Scopes {
-		selectors = append(selectors, api.ScopedResourceSelectorRequirement{
+		selectors = append(selectors, corev1.ScopedResourceSelectorRequirement{
 			ScopeName: scope,
-			Operator:  api.ScopeSelectorOpExists})
+			Operator:  corev1.ScopeSelectorOpExists})
 	}
 	if quota.Spec.ScopeSelector != nil {
 		for _, scopeSelector := range quota.Spec.ScopeSelector.MatchExpressions {
@@ -680,7 +680,7 @@ func (e *quotaEvaluator) getWork() (string, []*admissionWaiter, bool) {
 
 // prettyPrint formats a resource list for usage in errors
 // it outputs resources sorted in increasing order
-func prettyPrint(item api.ResourceList) string {
+func prettyPrint(item corev1.ResourceList) string {
 	parts := []string{}
 	keys := []string{}
 	for key := range item {
@@ -688,14 +688,14 @@ func prettyPrint(item api.ResourceList) string {
 	}
 	sort.Strings(keys)
 	for _, key := range keys {
-		value := item[api.ResourceName(key)]
+		value := item[corev1.ResourceName(key)]
 		constraint := key + "=" + value.String()
 		parts = append(parts, constraint)
 	}
 	return strings.Join(parts, ",")
 }
 
-func prettyPrintResourceNames(a []api.ResourceName) string {
+func prettyPrintResourceNames(a []corev1.ResourceName) string {
 	values := []string{}
 	for _, value := range a {
 		values = append(values, string(value))
@@ -705,7 +705,7 @@ func prettyPrintResourceNames(a []api.ResourceName) string {
 }
 
 // hasUsageStats returns true if for each hard constraint there is a value for its current usage
-func hasUsageStats(resourceQuota *api.ResourceQuota) bool {
+func hasUsageStats(resourceQuota *corev1.ResourceQuota) bool {
 	for resourceName := range resourceQuota.Status.Hard {
 		if _, found := resourceQuota.Status.Used[resourceName]; !found {
 			return false
diff --git a/plugin/pkg/admission/resourcequota/resource_access.go b/plugin/pkg/admission/resourcequota/resource_access.go
index c7e12d6c8e0..f703d478b33 100644
--- a/plugin/pkg/admission/resourcequota/resource_access.go
+++ b/plugin/pkg/admission/resourcequota/resource_access.go
@@ -20,14 +20,14 @@ import (
 	"fmt"
 	"time"
 
-	lru "github.com/hashicorp/golang-lru"
+	"github.com/hashicorp/golang-lru"
 
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apiserver/pkg/storage/etcd"
-	api "k8s.io/kubernetes/pkg/apis/core"
-	clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
-	corelisters "k8s.io/kubernetes/pkg/client/listers/core/internalversion"
+	"k8s.io/client-go/kubernetes"
+	corev1listers "k8s.io/client-go/listers/core/v1"
 )
 
 // QuotaAccessor abstracts the get/set logic from the rest of the Evaluator.  This could be a test stub, a straight passthrough,
@@ -35,17 +35,17 @@ import (
 type QuotaAccessor interface {
 	// UpdateQuotaStatus is called to persist final status.  This method should write to persistent storage.
 	// An error indicates that write didn't complete successfully.
-	UpdateQuotaStatus(newQuota *api.ResourceQuota) error
+	UpdateQuotaStatus(newQuota *corev1.ResourceQuota) error
 
 	// GetQuotas gets all possible quotas for a given namespace
-	GetQuotas(namespace string) ([]api.ResourceQuota, error)
+	GetQuotas(namespace string) ([]corev1.ResourceQuota, error)
 }
 
 type quotaAccessor struct {
-	client clientset.Interface
+	client kubernetes.Interface
 
 	// lister can list/get quota objects from a shared informer's cache
-	lister corelisters.ResourceQuotaLister
+	lister corev1listers.ResourceQuotaLister
 
 	// liveLookups holds the last few live lookups we've done to help ammortize cost on repeated lookup failures.
 	// This lets us handle the case of latent caches, by looking up actual results for a namespace on cache miss/no results.
@@ -77,8 +77,8 @@ func newQuotaAccessor() (*quotaAccessor, error) {
 	}, nil
 }
 
-func (e *quotaAccessor) UpdateQuotaStatus(newQuota *api.ResourceQuota) error {
-	updatedQuota, err := e.client.Core().ResourceQuotas(newQuota.Namespace).UpdateStatus(newQuota)
+func (e *quotaAccessor) UpdateQuotaStatus(newQuota *corev1.ResourceQuota) error {
+	updatedQuota, err := e.client.CoreV1().ResourceQuotas(newQuota.Namespace).UpdateStatus(newQuota)
 	if err != nil {
 		return err
 	}
@@ -93,13 +93,13 @@ var etcdVersioner = etcd.APIObjectVersioner{}
 // checkCache compares the passed quota against the value in the look-aside cache and returns the newer
 // if the cache is out of date, it deletes the stale entry.  This only works because of etcd resourceVersions
 // being monotonically increasing integers
-func (e *quotaAccessor) checkCache(quota *api.ResourceQuota) *api.ResourceQuota {
+func (e *quotaAccessor) checkCache(quota *corev1.ResourceQuota) *corev1.ResourceQuota {
 	key := quota.Namespace + "/" + quota.Name
 	uncastCachedQuota, ok := e.updatedQuotas.Get(key)
 	if !ok {
 		return quota
 	}
-	cachedQuota := uncastCachedQuota.(*api.ResourceQuota)
+	cachedQuota := uncastCachedQuota.(*corev1.ResourceQuota)
 
 	if etcdVersioner.CompareResourceVersion(quota, cachedQuota) >= 0 {
 		e.updatedQuotas.Remove(key)
@@ -108,7 +108,7 @@ func (e *quotaAccessor) checkCache(quota *api.ResourceQuota) *api.ResourceQuota
 	return cachedQuota
 }
 
-func (e *quotaAccessor) GetQuotas(namespace string) ([]api.ResourceQuota, error) {
+func (e *quotaAccessor) GetQuotas(namespace string) ([]corev1.ResourceQuota, error) {
 	// determine if there are any quotas in this namespace
 	// if there are no quotas, we don't need to do anything
 	items, err := e.lister.ResourceQuotas(namespace).List(labels.Everything())
@@ -142,7 +142,7 @@ func (e *quotaAccessor) GetQuotas(namespace string) ([]api.ResourceQuota, error)
 		}
 	}
 
-	resourceQuotas := []api.ResourceQuota{}
+	resourceQuotas := []corev1.ResourceQuota{}
 	for i := range items {
 		quota := items[i]
 		quota = e.checkCache(quota)