diff --git a/cmd/kube-apiserver/app/testing/testserver.go b/cmd/kube-apiserver/app/testing/testserver.go
index d1a26dc7592..5638a0e0afe 100644
--- a/cmd/kube-apiserver/app/testing/testserver.go
+++ b/cmd/kube-apiserver/app/testing/testserver.go
@@ -106,7 +106,7 @@ func StartTestServer(t *testing.T) (result *restclient.Config, tearDownForCaller
 		default:
 		}
 
-		result := client.CoreV1Client.RESTClient().Get().AbsPath("/healthz").Do()
+		result := client.CoreV1().RESTClient().Get().AbsPath("/healthz").Do()
 		status := 0
 		result.StatusCode(&status)
 		if status == 200 {
diff --git a/cmd/kubeadm/app/phases/markmaster/BUILD b/cmd/kubeadm/app/phases/markmaster/BUILD
index d611e941a36..7495e2bc1f9 100644
--- a/cmd/kubeadm/app/phases/markmaster/BUILD
+++ b/cmd/kubeadm/app/phases/markmaster/BUILD
@@ -20,7 +20,6 @@ go_test(
         "//vendor/k8s.io/api/core/v1:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes:go_default_library",
-        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
         "//vendor/k8s.io/client-go/rest:go_default_library",
     ],
 )
diff --git a/cmd/kubeadm/app/phases/markmaster/markmaster_test.go b/cmd/kubeadm/app/phases/markmaster/markmaster_test.go
index ea82a45a804..02dda93a06b 100644
--- a/cmd/kubeadm/app/phases/markmaster/markmaster_test.go
+++ b/cmd/kubeadm/app/phases/markmaster/markmaster_test.go
@@ -27,7 +27,6 @@ import (
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	clientset "k8s.io/client-go/kubernetes"
-	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 	restclient "k8s.io/client-go/rest"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeletapis "k8s.io/kubernetes/pkg/kubelet/apis"
@@ -121,7 +120,7 @@ func TestMarkMaster(t *testing.T) {
 		}))
 		defer s.Close()
 
-		cs, err := clientsetFromTestServer(s)
+		cs, err := clientset.NewForConfig(&restclient.Config{Host: s.URL})
 		if err != nil {
 			t.Fatalf("MarkMaster(%s): unexpected error building clientset: %v", tc.name, err)
 		}
@@ -137,15 +136,6 @@ func TestMarkMaster(t *testing.T) {
 	}
 }
 
-func clientsetFromTestServer(s *httptest.Server) (*clientset.Clientset, error) {
-	rc := &restclient.Config{Host: s.URL}
-	c, err := corev1.NewForConfig(rc)
-	if err != nil {
-		return nil, err
-	}
-	return &clientset.Clientset{CoreV1Client: c}, nil
-}
-
 func toString(r io.Reader) string {
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(r)
diff --git a/cmd/kubelet/app/server.go b/cmd/kubelet/app/server.go
index b005383289a..77cf0c37e7e 100644
--- a/cmd/kubelet/app/server.go
+++ b/cmd/kubelet/app/server.go
@@ -203,14 +203,14 @@ func getRemoteKubeletConfig(s *options.KubeletServer, kubeDeps *kubelet.Dependen
 				return nil, err
 			}
 			// look for kubelet-<node-name> configmap from "kube-system"
-			configmap, err := kubeClient.CoreV1Client.ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", nodename), metav1.GetOptions{})
+			configmap, err := kubeClient.CoreV1().ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", nodename), metav1.GetOptions{})
 			if err != nil {
 				return nil, err
 			}
 			return configmap, nil
 		}
 		// No cloud provider yet, so can't get the nodename via Cloud.Instances().CurrentNodeName(hostname), try just using the hostname
-		configmap, err := kubeClient.CoreV1Client.ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", hostname), metav1.GetOptions{})
+		configmap, err := kubeClient.CoreV1().ConfigMaps("kube-system").Get(fmt.Sprintf("kubelet-%s", hostname), metav1.GetOptions{})
 		if err != nil {
 			return nil, fmt.Errorf("cloud provider was nil, and attempt to use hostname to find config resulted in: %v", err)
 		}
diff --git a/cmd/kubemark/hollow-node.go b/cmd/kubemark/hollow-node.go
index 025a954f72e..a6f7d307475 100644
--- a/cmd/kubemark/hollow-node.go
+++ b/cmd/kubemark/hollow-node.go
@@ -147,7 +147,7 @@ func main() {
 		hollowProxy, err := kubemark.NewHollowProxyOrDie(
 			config.NodeName,
 			internalClientset,
-			client.Core(),
+			client.CoreV1(),
 			iptInterface,
 			sysctl,
 			execer,
diff --git a/federation/client/clientset_generated/federation_clientset/clientset.go b/federation/client/clientset_generated/federation_clientset/clientset.go
index b77b2dbb341..38b461c111a 100644
--- a/federation/client/clientset_generated/federation_clientset/clientset.go
+++ b/federation/client/clientset_generated/federation_clientset/clientset.go
@@ -51,66 +51,66 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*autoscalingv1.AutoscalingV1Client
-	*batchv1.BatchV1Client
-	*corev1.CoreV1Client
-	*extensionsv1beta1.ExtensionsV1beta1Client
-	*federationv1beta1.FederationV1beta1Client
+	autoscalingV1     *autoscalingv1.AutoscalingV1Client
+	batchV1           *batchv1.BatchV1Client
+	coreV1            *corev1.CoreV1Client
+	extensionsV1beta1 *extensionsv1beta1.ExtensionsV1beta1Client
+	federationV1beta1 *federationv1beta1.FederationV1beta1Client
 }
 
 // AutoscalingV1 retrieves the AutoscalingV1Client
 func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
-	return c.AutoscalingV1Client
+	return c.autoscalingV1
 }
 
 // Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
 // Please explicitly pick a version.
 func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
-	return c.AutoscalingV1Client
+	return c.autoscalingV1
 }
 
 // BatchV1 retrieves the BatchV1Client
 func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
-	return c.BatchV1Client
+	return c.batchV1
 }
 
 // Deprecated: Batch retrieves the default version of BatchClient.
 // Please explicitly pick a version.
 func (c *Clientset) Batch() batchv1.BatchV1Interface {
-	return c.BatchV1Client
+	return c.batchV1
 }
 
 // CoreV1 retrieves the CoreV1Client
 func (c *Clientset) CoreV1() corev1.CoreV1Interface {
-	return c.CoreV1Client
+	return c.coreV1
 }
 
 // Deprecated: Core retrieves the default version of CoreClient.
 // Please explicitly pick a version.
 func (c *Clientset) Core() corev1.CoreV1Interface {
-	return c.CoreV1Client
+	return c.coreV1
 }
 
 // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
 func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return c.ExtensionsV1beta1Client
+	return c.extensionsV1beta1
 }
 
 // Deprecated: Extensions retrieves the default version of ExtensionsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return c.ExtensionsV1beta1Client
+	return c.extensionsV1beta1
 }
 
 // FederationV1beta1 retrieves the FederationV1beta1Client
 func (c *Clientset) FederationV1beta1() federationv1beta1.FederationV1beta1Interface {
-	return c.FederationV1beta1Client
+	return c.federationV1beta1
 }
 
 // Deprecated: Federation retrieves the default version of FederationClient.
 // Please explicitly pick a version.
 func (c *Clientset) Federation() federationv1beta1.FederationV1beta1Interface {
-	return c.FederationV1beta1Client
+	return c.federationV1beta1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -129,23 +129,23 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy)
+	cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy)
+	cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy)
+	cs.coreV1, err = corev1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
+	cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.FederationV1beta1Client, err = federationv1beta1.NewForConfig(&configShallowCopy)
+	cs.federationV1beta1, err = federationv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -162,11 +162,11 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c)
-	cs.BatchV1Client = batchv1.NewForConfigOrDie(c)
-	cs.CoreV1Client = corev1.NewForConfigOrDie(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c)
-	cs.FederationV1beta1Client = federationv1beta1.NewForConfigOrDie(c)
+	cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c)
+	cs.batchV1 = batchv1.NewForConfigOrDie(c)
+	cs.coreV1 = corev1.NewForConfigOrDie(c)
+	cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
+	cs.federationV1beta1 = federationv1beta1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -175,11 +175,11 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.AutoscalingV1Client = autoscalingv1.New(c)
-	cs.BatchV1Client = batchv1.New(c)
-	cs.CoreV1Client = corev1.New(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c)
-	cs.FederationV1beta1Client = federationv1beta1.New(c)
+	cs.autoscalingV1 = autoscalingv1.New(c)
+	cs.batchV1 = batchv1.New(c)
+	cs.coreV1 = corev1.New(c)
+	cs.extensionsV1beta1 = extensionsv1beta1.New(c)
+	cs.federationV1beta1 = federationv1beta1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/pkg/client/clientset_generated/internalclientset/clientset.go b/pkg/client/clientset_generated/internalclientset/clientset.go
index 0fab4ccdc4e..c7eb9d437ca 100644
--- a/pkg/client/clientset_generated/internalclientset/clientset.go
+++ b/pkg/client/clientset_generated/internalclientset/clientset.go
@@ -61,96 +61,96 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*admissionregistrationinternalversion.AdmissionregistrationClient
-	*coreinternalversion.CoreClient
-	*appsinternalversion.AppsClient
-	*authenticationinternalversion.AuthenticationClient
-	*authorizationinternalversion.AuthorizationClient
-	*autoscalinginternalversion.AutoscalingClient
-	*batchinternalversion.BatchClient
-	*certificatesinternalversion.CertificatesClient
-	*extensionsinternalversion.ExtensionsClient
-	*networkinginternalversion.NetworkingClient
-	*policyinternalversion.PolicyClient
-	*rbacinternalversion.RbacClient
-	*schedulinginternalversion.SchedulingClient
-	*settingsinternalversion.SettingsClient
-	*storageinternalversion.StorageClient
+	admissionregistration *admissionregistrationinternalversion.AdmissionregistrationClient
+	core                  *coreinternalversion.CoreClient
+	apps                  *appsinternalversion.AppsClient
+	authentication        *authenticationinternalversion.AuthenticationClient
+	authorization         *authorizationinternalversion.AuthorizationClient
+	autoscaling           *autoscalinginternalversion.AutoscalingClient
+	batch                 *batchinternalversion.BatchClient
+	certificates          *certificatesinternalversion.CertificatesClient
+	extensions            *extensionsinternalversion.ExtensionsClient
+	networking            *networkinginternalversion.NetworkingClient
+	policy                *policyinternalversion.PolicyClient
+	rbac                  *rbacinternalversion.RbacClient
+	scheduling            *schedulinginternalversion.SchedulingClient
+	settings              *settingsinternalversion.SettingsClient
+	storage               *storageinternalversion.StorageClient
 }
 
 // Admissionregistration retrieves the AdmissionregistrationClient
 func (c *Clientset) Admissionregistration() admissionregistrationinternalversion.AdmissionregistrationInterface {
-	return c.AdmissionregistrationClient
+	return c.admissionregistration
 }
 
 // Core retrieves the CoreClient
 func (c *Clientset) Core() coreinternalversion.CoreInterface {
-	return c.CoreClient
+	return c.core
 }
 
 // Apps retrieves the AppsClient
 func (c *Clientset) Apps() appsinternalversion.AppsInterface {
-	return c.AppsClient
+	return c.apps
 }
 
 // Authentication retrieves the AuthenticationClient
 func (c *Clientset) Authentication() authenticationinternalversion.AuthenticationInterface {
-	return c.AuthenticationClient
+	return c.authentication
 }
 
 // Authorization retrieves the AuthorizationClient
 func (c *Clientset) Authorization() authorizationinternalversion.AuthorizationInterface {
-	return c.AuthorizationClient
+	return c.authorization
 }
 
 // Autoscaling retrieves the AutoscalingClient
 func (c *Clientset) Autoscaling() autoscalinginternalversion.AutoscalingInterface {
-	return c.AutoscalingClient
+	return c.autoscaling
 }
 
 // Batch retrieves the BatchClient
 func (c *Clientset) Batch() batchinternalversion.BatchInterface {
-	return c.BatchClient
+	return c.batch
 }
 
 // Certificates retrieves the CertificatesClient
 func (c *Clientset) Certificates() certificatesinternalversion.CertificatesInterface {
-	return c.CertificatesClient
+	return c.certificates
 }
 
 // Extensions retrieves the ExtensionsClient
 func (c *Clientset) Extensions() extensionsinternalversion.ExtensionsInterface {
-	return c.ExtensionsClient
+	return c.extensions
 }
 
 // Networking retrieves the NetworkingClient
 func (c *Clientset) Networking() networkinginternalversion.NetworkingInterface {
-	return c.NetworkingClient
+	return c.networking
 }
 
 // Policy retrieves the PolicyClient
 func (c *Clientset) Policy() policyinternalversion.PolicyInterface {
-	return c.PolicyClient
+	return c.policy
 }
 
 // Rbac retrieves the RbacClient
 func (c *Clientset) Rbac() rbacinternalversion.RbacInterface {
-	return c.RbacClient
+	return c.rbac
 }
 
 // Scheduling retrieves the SchedulingClient
 func (c *Clientset) Scheduling() schedulinginternalversion.SchedulingInterface {
-	return c.SchedulingClient
+	return c.scheduling
 }
 
 // Settings retrieves the SettingsClient
 func (c *Clientset) Settings() settingsinternalversion.SettingsInterface {
-	return c.SettingsClient
+	return c.settings
 }
 
 // Storage retrieves the StorageClient
 func (c *Clientset) Storage() storageinternalversion.StorageInterface {
-	return c.StorageClient
+	return c.storage
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -169,63 +169,63 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.AdmissionregistrationClient, err = admissionregistrationinternalversion.NewForConfig(&configShallowCopy)
+	cs.admissionregistration, err = admissionregistrationinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CoreClient, err = coreinternalversion.NewForConfig(&configShallowCopy)
+	cs.core, err = coreinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AppsClient, err = appsinternalversion.NewForConfig(&configShallowCopy)
+	cs.apps, err = appsinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthenticationClient, err = authenticationinternalversion.NewForConfig(&configShallowCopy)
+	cs.authentication, err = authenticationinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthorizationClient, err = authorizationinternalversion.NewForConfig(&configShallowCopy)
+	cs.authorization, err = authorizationinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AutoscalingClient, err = autoscalinginternalversion.NewForConfig(&configShallowCopy)
+	cs.autoscaling, err = autoscalinginternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchClient, err = batchinternalversion.NewForConfig(&configShallowCopy)
+	cs.batch, err = batchinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CertificatesClient, err = certificatesinternalversion.NewForConfig(&configShallowCopy)
+	cs.certificates, err = certificatesinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.ExtensionsClient, err = extensionsinternalversion.NewForConfig(&configShallowCopy)
+	cs.extensions, err = extensionsinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.NetworkingClient, err = networkinginternalversion.NewForConfig(&configShallowCopy)
+	cs.networking, err = networkinginternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.PolicyClient, err = policyinternalversion.NewForConfig(&configShallowCopy)
+	cs.policy, err = policyinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.RbacClient, err = rbacinternalversion.NewForConfig(&configShallowCopy)
+	cs.rbac, err = rbacinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.SchedulingClient, err = schedulinginternalversion.NewForConfig(&configShallowCopy)
+	cs.scheduling, err = schedulinginternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.SettingsClient, err = settingsinternalversion.NewForConfig(&configShallowCopy)
+	cs.settings, err = settingsinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.StorageClient, err = storageinternalversion.NewForConfig(&configShallowCopy)
+	cs.storage, err = storageinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -242,21 +242,21 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.AdmissionregistrationClient = admissionregistrationinternalversion.NewForConfigOrDie(c)
-	cs.CoreClient = coreinternalversion.NewForConfigOrDie(c)
-	cs.AppsClient = appsinternalversion.NewForConfigOrDie(c)
-	cs.AuthenticationClient = authenticationinternalversion.NewForConfigOrDie(c)
-	cs.AuthorizationClient = authorizationinternalversion.NewForConfigOrDie(c)
-	cs.AutoscalingClient = autoscalinginternalversion.NewForConfigOrDie(c)
-	cs.BatchClient = batchinternalversion.NewForConfigOrDie(c)
-	cs.CertificatesClient = certificatesinternalversion.NewForConfigOrDie(c)
-	cs.ExtensionsClient = extensionsinternalversion.NewForConfigOrDie(c)
-	cs.NetworkingClient = networkinginternalversion.NewForConfigOrDie(c)
-	cs.PolicyClient = policyinternalversion.NewForConfigOrDie(c)
-	cs.RbacClient = rbacinternalversion.NewForConfigOrDie(c)
-	cs.SchedulingClient = schedulinginternalversion.NewForConfigOrDie(c)
-	cs.SettingsClient = settingsinternalversion.NewForConfigOrDie(c)
-	cs.StorageClient = storageinternalversion.NewForConfigOrDie(c)
+	cs.admissionregistration = admissionregistrationinternalversion.NewForConfigOrDie(c)
+	cs.core = coreinternalversion.NewForConfigOrDie(c)
+	cs.apps = appsinternalversion.NewForConfigOrDie(c)
+	cs.authentication = authenticationinternalversion.NewForConfigOrDie(c)
+	cs.authorization = authorizationinternalversion.NewForConfigOrDie(c)
+	cs.autoscaling = autoscalinginternalversion.NewForConfigOrDie(c)
+	cs.batch = batchinternalversion.NewForConfigOrDie(c)
+	cs.certificates = certificatesinternalversion.NewForConfigOrDie(c)
+	cs.extensions = extensionsinternalversion.NewForConfigOrDie(c)
+	cs.networking = networkinginternalversion.NewForConfigOrDie(c)
+	cs.policy = policyinternalversion.NewForConfigOrDie(c)
+	cs.rbac = rbacinternalversion.NewForConfigOrDie(c)
+	cs.scheduling = schedulinginternalversion.NewForConfigOrDie(c)
+	cs.settings = settingsinternalversion.NewForConfigOrDie(c)
+	cs.storage = storageinternalversion.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -265,21 +265,21 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.AdmissionregistrationClient = admissionregistrationinternalversion.New(c)
-	cs.CoreClient = coreinternalversion.New(c)
-	cs.AppsClient = appsinternalversion.New(c)
-	cs.AuthenticationClient = authenticationinternalversion.New(c)
-	cs.AuthorizationClient = authorizationinternalversion.New(c)
-	cs.AutoscalingClient = autoscalinginternalversion.New(c)
-	cs.BatchClient = batchinternalversion.New(c)
-	cs.CertificatesClient = certificatesinternalversion.New(c)
-	cs.ExtensionsClient = extensionsinternalversion.New(c)
-	cs.NetworkingClient = networkinginternalversion.New(c)
-	cs.PolicyClient = policyinternalversion.New(c)
-	cs.RbacClient = rbacinternalversion.New(c)
-	cs.SchedulingClient = schedulinginternalversion.New(c)
-	cs.SettingsClient = settingsinternalversion.New(c)
-	cs.StorageClient = storageinternalversion.New(c)
+	cs.admissionregistration = admissionregistrationinternalversion.New(c)
+	cs.core = coreinternalversion.New(c)
+	cs.apps = appsinternalversion.New(c)
+	cs.authentication = authenticationinternalversion.New(c)
+	cs.authorization = authorizationinternalversion.New(c)
+	cs.autoscaling = autoscalinginternalversion.New(c)
+	cs.batch = batchinternalversion.New(c)
+	cs.certificates = certificatesinternalversion.New(c)
+	cs.extensions = extensionsinternalversion.New(c)
+	cs.networking = networkinginternalversion.New(c)
+	cs.policy = policyinternalversion.New(c)
+	cs.rbac = rbacinternalversion.New(c)
+	cs.scheduling = schedulinginternalversion.New(c)
+	cs.settings = settingsinternalversion.New(c)
+	cs.storage = storageinternalversion.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/pkg/controller/deployment/deployment_controller.go b/pkg/controller/deployment/deployment_controller.go
index 56eecf59564..f9c2f0ad26e 100644
--- a/pkg/controller/deployment/deployment_controller.go
+++ b/pkg/controller/deployment/deployment_controller.go
@@ -355,7 +355,7 @@ func (dc *DeploymentController) deletePod(obj interface{}) {
 	glog.V(4).Infof("Pod %s deleted.", pod.Name)
 	if d := dc.getDeploymentForPod(pod); d != nil && d.Spec.Strategy.Type == extensions.RecreateDeploymentStrategyType {
 		// Sync if this Deployment now has no more Pods.
-		rsList, err := util.ListReplicaSets(d, util.RsListFromClient(dc.client))
+		rsList, err := util.ListReplicaSets(d, util.RsListFromClient(dc.client.ExtensionsV1beta1()))
 		if err != nil {
 			return
 		}
diff --git a/pkg/controller/deployment/util/deployment_util.go b/pkg/controller/deployment/util/deployment_util.go
index f994a8c94bd..47eea5d3c39 100644
--- a/pkg/controller/deployment/util/deployment_util.go
+++ b/pkg/controller/deployment/util/deployment_util.go
@@ -37,6 +37,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/wait"
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/kubernetes/scheme"
+	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	corelisters "k8s.io/client-go/listers/core/v1"
 	extensionslisters "k8s.io/client-go/listers/extensions/v1beta1"
 	"k8s.io/client-go/util/integer"
@@ -497,7 +498,7 @@ func getReplicaSetFraction(rs extensions.ReplicaSet, d extensions.Deployment) in
 // GetAllReplicaSets returns the old and new replica sets targeted by the given Deployment. It gets PodList and ReplicaSetList from client interface.
 // Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
 // The third returned value is the new replica set, and it may be nil if it doesn't exist yet.
-func GetAllReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, *extensions.ReplicaSet, error) {
+func GetAllReplicaSets(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, *extensions.ReplicaSet, error) {
 	rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
 	if err != nil {
 		return nil, nil, nil, err
@@ -515,7 +516,7 @@ func GetAllReplicaSets(deployment *extensions.Deployment, c clientset.Interface)
 
 // GetOldReplicaSets returns the old replica sets targeted by the given Deployment; get PodList and ReplicaSetList from client interface.
 // Note that the first set of old replica sets doesn't include the ones with no pods, and the second set of old replica sets include all old replica sets.
-func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, error) {
+func GetOldReplicaSets(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) ([]*extensions.ReplicaSet, []*extensions.ReplicaSet, error) {
 	rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
 	if err != nil {
 		return nil, nil, err
@@ -525,7 +526,7 @@ func GetOldReplicaSets(deployment *extensions.Deployment, c clientset.Interface)
 
 // GetNewReplicaSet returns a replica set that matches the intent of the given deployment; get ReplicaSetList from client interface.
 // Returns nil if the new replica set doesn't exist yet.
-func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface) (*extensions.ReplicaSet, error) {
+func GetNewReplicaSet(deployment *extensions.Deployment, c extensionsv1beta1.ExtensionsV1beta1Interface) (*extensions.ReplicaSet, error) {
 	rsList, err := ListReplicaSets(deployment, RsListFromClient(c))
 	if err != nil {
 		return nil, err
@@ -534,9 +535,9 @@ func GetNewReplicaSet(deployment *extensions.Deployment, c clientset.Interface)
 }
 
 // RsListFromClient returns an rsListFunc that wraps the given client.
-func RsListFromClient(c clientset.Interface) RsListFunc {
+func RsListFromClient(c extensionsv1beta1.ExtensionsV1beta1Interface) RsListFunc {
 	return func(namespace string, options metav1.ListOptions) ([]*extensions.ReplicaSet, error) {
-		rsList, err := c.Extensions().ReplicaSets(namespace).List(options)
+		rsList, err := c.ReplicaSets(namespace).List(options)
 		if err != nil {
 			return nil, err
 		}
diff --git a/pkg/controller/deployment/util/deployment_util_test.go b/pkg/controller/deployment/util/deployment_util_test.go
index d28f1f80bf2..3540198a918 100644
--- a/pkg/controller/deployment/util/deployment_util_test.go
+++ b/pkg/controller/deployment/util/deployment_util_test.go
@@ -288,7 +288,7 @@ func TestGetNewRS(t *testing.T) {
 			fakeClient = addListRSReactor(fakeClient, test.objs[1])
 			fakeClient = addUpdatePodsReactor(fakeClient)
 			fakeClient = addUpdateRSReactor(fakeClient)
-			rs, err := GetNewReplicaSet(&newDeployment, fakeClient)
+			rs, err := GetNewReplicaSet(&newDeployment, fakeClient.ExtensionsV1beta1())
 			if err != nil {
 				t.Errorf("In test case %s, got unexpected error %v", test.Name, err)
 			}
@@ -361,7 +361,7 @@ func TestGetOldRSs(t *testing.T) {
 			fakeClient = addListRSReactor(fakeClient, test.objs[0])
 			fakeClient = addGetRSReactor(fakeClient, test.objs[0])
 			fakeClient = addUpdateRSReactor(fakeClient)
-			_, rss, err := GetOldReplicaSets(&newDeployment, fakeClient)
+			_, rss, err := GetOldReplicaSets(&newDeployment, fakeClient.ExtensionsV1beta1())
 			if err != nil {
 				t.Errorf("In test case %s, got unexpected error %v", test.Name, err)
 			}
diff --git a/pkg/kubectl/BUILD b/pkg/kubectl/BUILD
index 52a40a1c946..7ba148beb69 100644
--- a/pkg/kubectl/BUILD
+++ b/pkg/kubectl/BUILD
@@ -172,9 +172,7 @@ go_library(
         "//vendor/k8s.io/apimachinery/pkg/util/validation:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
-        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes/typed/apps/v1beta1:go_default_library",
-        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library",
         "//vendor/k8s.io/client-go/rest:go_default_library",
         "//vendor/k8s.io/client-go/util/integer:go_default_library",
diff --git a/pkg/kubectl/cmd/testing/fake.go b/pkg/kubectl/cmd/testing/fake.go
index 0f66cafa143..b69bc1123ef 100644
--- a/pkg/kubectl/cmd/testing/fake.go
+++ b/pkg/kubectl/cmd/testing/fake.go
@@ -587,17 +587,17 @@ func (f *fakeAPIFactory) ClientSet() (internalclientset.Interface, error) {
 	// version.
 	fakeClient := f.tf.Client.(*fake.RESTClient)
 	clientset := internalclientset.NewForConfigOrDie(f.tf.ClientConfig)
-	clientset.CoreClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.AuthenticationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.AuthorizationClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.AutoscalingClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.BatchClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.CertificatesClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.ExtensionsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.RbacClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.StorageClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.AppsClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
-	clientset.PolicyClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Core().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Authentication().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Authorization().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Autoscaling().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Batch().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Certificates().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Extensions().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Rbac().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Storage().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Apps().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+	clientset.Policy().RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
 	clientset.DiscoveryClient.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
 	return clientset, f.tf.Err
 }
diff --git a/pkg/kubectl/history.go b/pkg/kubectl/history.go
index b1feece1511..d8051c8b0c4 100644
--- a/pkg/kubectl/history.go
+++ b/pkg/kubectl/history.go
@@ -31,7 +31,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/json"
 	"k8s.io/apimachinery/pkg/util/strategicpatch"
-	externalclientset "k8s.io/client-go/kubernetes"
+	clientappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
+	clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	"k8s.io/kubernetes/pkg/api"
 	k8s_api_v1 "k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/apis/apps"
@@ -71,12 +72,12 @@ type DeploymentHistoryViewer struct {
 // ViewHistory returns a revision-to-replicaset map as the revision history of a deployment
 // TODO: this should be a describer
 func (h *DeploymentHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
-	versionedClient := versionedClientsetForDeployment(h.c)
-	deployment, err := versionedClient.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{})
+	versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
+	deployment, err := versionedExtensionsClient.Deployments(namespace).Get(name, metav1.GetOptions{})
 	if err != nil {
 		return "", fmt.Errorf("failed to retrieve deployment %s: %v", name, err)
 	}
-	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, versionedClient)
+	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, versionedExtensionsClient)
 	if err != nil {
 		return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", name, err)
 	}
@@ -153,8 +154,9 @@ type DaemonSetHistoryViewer struct {
 // ViewHistory returns a revision-to-history map as the revision history of a deployment
 // TODO: this should be a describer
 func (h *DaemonSetHistoryViewer) ViewHistory(namespace, name string, revision int64) (string, error) {
-	versionedClient := versionedClientsetForDaemonSet(h.c)
-	ds, allHistory, err := controlledHistories(versionedClient, namespace, name)
+	versionedExtensionsClient := versionedExtensionsClientV1beta1(h.c)
+	versionedAppsClient := versionedAppsClientV1beta1(h.c)
+	ds, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, namespace, name)
 	if err != nil {
 		return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", name, err)
 	}
@@ -256,8 +258,8 @@ func (h *StatefulSetHistoryViewer) ViewHistory(namespace, name string, revision
 }
 
 // controlledHistories returns all ControllerRevisions controlled by the given DaemonSet
-func controlledHistories(c externalclientset.Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) {
-	ds, err := c.ExtensionsV1beta1().DaemonSets(namespace).Get(name, metav1.GetOptions{})
+func controlledHistories(extensions clientextensionsv1beta1.ExtensionsV1beta1Interface, apps clientappsv1beta1.AppsV1beta1Interface, namespace, name string) (*extensionsv1beta1.DaemonSet, []*appsv1beta1.ControllerRevision, error) {
+	ds, err := extensions.DaemonSets(namespace).Get(name, metav1.GetOptions{})
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to retrieve DaemonSet %s: %v", name, err)
 	}
@@ -266,7 +268,7 @@ func controlledHistories(c externalclientset.Interface, namespace, name string)
 	if err != nil {
 		return nil, nil, err
 	}
-	historyList, err := c.AppsV1beta1().ControllerRevisions(ds.Namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
+	historyList, err := apps.ControllerRevisions(ds.Namespace).List(metav1.ListOptions{LabelSelector: selector.String()})
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/pkg/kubectl/rollback.go b/pkg/kubectl/rollback.go
index 5312bfbeb99..c3511700325 100644
--- a/pkg/kubectl/rollback.go
+++ b/pkg/kubectl/rollback.go
@@ -151,8 +151,8 @@ func simpleDryRun(deployment *extensions.Deployment, c clientset.Interface, toRe
 	if err := api.Scheme.Convert(deployment, externalDeployment, nil); err != nil {
 		return "", fmt.Errorf("failed to convert deployment, %v", err)
 	}
-	versionedClient := versionedClientsetForDeployment(c)
-	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedClient)
+	versionedExtensionsClient := versionedExtensionsClientV1beta1(c)
+	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(externalDeployment, versionedExtensionsClient)
 	if err != nil {
 		return "", fmt.Errorf("failed to retrieve replica sets from deployment %s: %v", deployment.Name, err)
 	}
@@ -221,8 +221,9 @@ func (r *DaemonSetRollbacker) Rollback(obj runtime.Object, updatedAnnotations ma
 	if !ok {
 		return "", fmt.Errorf("passed object is not a DaemonSet: %#v", obj)
 	}
-	versionedClient := versionedClientsetForDaemonSet(r.c)
-	versionedDS, allHistory, err := controlledHistories(versionedClient, ds.Namespace, ds.Name)
+	versionedExtensionsClient := versionedExtensionsClientV1beta1(r.c)
+	versionedAppsClient := versionedAppsClientV1beta1(r.c)
+	versionedDS, allHistory, err := controlledHistories(versionedExtensionsClient, versionedAppsClient, ds.Namespace, ds.Name)
 	if err != nil {
 		return "", fmt.Errorf("unable to find history controlled by DaemonSet %s: %v", ds.Name, err)
 	}
@@ -275,7 +276,7 @@ func (r *DaemonSetRollbacker) Rollback(obj runtime.Object, updatedAnnotations ma
 	}
 
 	// Restore revision
-	if _, err = versionedClient.ExtensionsV1beta1().DaemonSets(ds.Namespace).Patch(ds.Name, types.StrategicMergePatchType, toHistory.Data.Raw); err != nil {
+	if _, err = versionedExtensionsClient.DaemonSets(ds.Namespace).Patch(ds.Name, types.StrategicMergePatchType, toHistory.Data.Raw); err != nil {
 		return "", fmt.Errorf("failed restoring revision %d: %v", toRevision, err)
 	}
 
diff --git a/pkg/kubectl/rolling_updater_test.go b/pkg/kubectl/rolling_updater_test.go
index 922104a3c9a..2070df1d554 100644
--- a/pkg/kubectl/rolling_updater_test.go
+++ b/pkg/kubectl/rolling_updater_test.go
@@ -1501,7 +1501,7 @@ func TestUpdateRcWithRetries(t *testing.T) {
 	clientset := internalclientset.New(restClient)
 
 	if rc, err := updateRcWithRetries(
-		clientset, "default", rc, func(c *api.ReplicationController) {
+		clientset.Core(), "default", rc, func(c *api.ReplicationController) {
 			c.Spec.Selector["baz"] = "foobar"
 		}); err != nil {
 		t.Errorf("unexpected error: %v", err)
diff --git a/pkg/kubectl/versioned_client.go b/pkg/kubectl/versioned_client.go
index 99757187cee..f381aed69d4 100644
--- a/pkg/kubectl/versioned_client.go
+++ b/pkg/kubectl/versioned_client.go
@@ -17,29 +17,23 @@ limitations under the License.
 package kubectl
 
 import (
-	externalclientset "k8s.io/client-go/kubernetes"
-	apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
-	core "k8s.io/client-go/kubernetes/typed/core/v1"
-	extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	clientappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
+	clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	internalclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 )
 
-func versionedClientsetForDeployment(internalClient internalclientset.Interface) externalclientset.Interface {
+// TODO: get rid of this and plumb the caller correctly
+func versionedExtensionsClientV1beta1(internalClient internalclientset.Interface) clientextensionsv1beta1.ExtensionsV1beta1Interface {
 	if internalClient == nil {
-		return &externalclientset.Clientset{}
-	}
-	return &externalclientset.Clientset{
-		CoreV1Client:            core.New(internalClient.Core().RESTClient()),
-		ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
+		return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
 	}
+	return clientextensionsv1beta1.New(internalClient.Extensions().RESTClient())
 }
 
-func versionedClientsetForDaemonSet(internalClient internalclientset.Interface) externalclientset.Interface {
+// TODO: get rid of this and plumb the caller correctly
+func versionedAppsClientV1beta1(internalClient internalclientset.Interface) clientappsv1beta1.AppsV1beta1Interface {
 	if internalClient == nil {
-		return &externalclientset.Clientset{}
-	}
-	return &externalclientset.Clientset{
-		AppsV1beta1Client:       apps.New(internalClient.Apps().RESTClient()),
-		ExtensionsV1beta1Client: extensions.New(internalClient.Extensions().RESTClient()),
+		return &clientappsv1beta1.AppsV1beta1Client{}
 	}
+	return clientappsv1beta1.New(internalClient.Apps().RESTClient())
 }
diff --git a/pkg/printers/internalversion/BUILD b/pkg/printers/internalversion/BUILD
index 965d2a4a23c..5b2f410bd20 100644
--- a/pkg/printers/internalversion/BUILD
+++ b/pkg/printers/internalversion/BUILD
@@ -112,8 +112,6 @@ go_library(
         "//vendor/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
         "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
         "//vendor/k8s.io/client-go/dynamic:go_default_library",
-        "//vendor/k8s.io/client-go/kubernetes:go_default_library",
-        "//vendor/k8s.io/client-go/kubernetes/typed/core/v1:go_default_library",
         "//vendor/k8s.io/client-go/kubernetes/typed/extensions/v1beta1:go_default_library",
     ],
 )
diff --git a/pkg/printers/internalversion/describe.go b/pkg/printers/internalversion/describe.go
index d8b3ae409a8..33f929e74c7 100644
--- a/pkg/printers/internalversion/describe.go
+++ b/pkg/printers/internalversion/describe.go
@@ -46,9 +46,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/dynamic"
-	versionedclientset "k8s.io/client-go/kubernetes"
-	coreclientset "k8s.io/client-go/kubernetes/typed/core/v1"
-	extensionsclientset "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	clientextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
 	federation "k8s.io/kubernetes/federation/apis/federation/v1beta1"
 	fedclientset "k8s.io/kubernetes/federation/client/clientset_generated/federation_clientset"
 	"k8s.io/kubernetes/pkg/api"
@@ -141,12 +139,12 @@ func describerMap(c clientset.Interface) map[schema.GroupKind]printers.Describer
 		extensions.Kind("PodSecurityPolicy"):           &PodSecurityPolicyDescriber{c},
 		autoscaling.Kind("HorizontalPodAutoscaler"):    &HorizontalPodAutoscalerDescriber{c},
 		extensions.Kind("DaemonSet"):                   &DaemonSetDescriber{c},
-		extensions.Kind("Deployment"):                  &DeploymentDescriber{c, versionedClientsetForDeployment(c)},
+		extensions.Kind("Deployment"):                  &DeploymentDescriber{c, versionedExtensionsClientV1beta1(c)},
 		extensions.Kind("Ingress"):                     &IngressDescriber{c},
 		batch.Kind("Job"):                              &JobDescriber{c},
 		batch.Kind("CronJob"):                          &CronJobDescriber{c},
 		apps.Kind("StatefulSet"):                       &StatefulSetDescriber{c},
-		apps.Kind("Deployment"):                        &DeploymentDescriber{c, versionedClientsetForDeployment(c)},
+		apps.Kind("Deployment"):                        &DeploymentDescriber{c, versionedExtensionsClientV1beta1(c)},
 		apps.Kind("DaemonSet"):                         &DaemonSetDescriber{c},
 		certificates.Kind("CertificateSigningRequest"): &CertificateSigningRequestDescriber{c},
 		storage.Kind("StorageClass"):                   &StorageClassDescriber{c},
@@ -2836,11 +2834,11 @@ func DescribeEvents(el *api.EventList, w PrefixWriter) {
 // DeploymentDescriber generates information about a deployment.
 type DeploymentDescriber struct {
 	clientset.Interface
-	versionedClient versionedclientset.Interface
+	extensionV1beta1Client clientextensionsv1beta1.ExtensionsV1beta1Interface
 }
 
 func (dd *DeploymentDescriber) Describe(namespace, name string, describerSettings printers.DescriberSettings) (string, error) {
-	d, err := dd.versionedClient.Extensions().Deployments(namespace).Get(name, metav1.GetOptions{})
+	d, err := dd.extensionV1beta1Client.Deployments(namespace).Get(name, metav1.GetOptions{})
 	if err != nil {
 		return "", err
 	}
@@ -2885,7 +2883,7 @@ func describeDeployment(d *versionedextension.Deployment, selector labels.Select
 				w.Write(LEVEL_1, "%v \t%v\t%v\n", c.Type, c.Status, c.Reason)
 			}
 		}
-		oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.versionedClient)
+		oldRSs, _, newRS, err := deploymentutil.GetAllReplicaSets(d, dd.extensionV1beta1Client)
 		if err == nil {
 			w.Write(LEVEL_0, "OldReplicaSets:\t%s\n", printReplicaSetsByLabels(oldRSs))
 			var newRSs []*versionedextension.ReplicaSet
@@ -3650,14 +3648,12 @@ func (list SortableVolumeMounts) Less(i, j int) bool {
 	return list[i].MountPath < list[j].MountPath
 }
 
-func versionedClientsetForDeployment(internalClient clientset.Interface) versionedclientset.Interface {
+// TODO: get rid of this and plumb the caller correctly
+func versionedExtensionsClientV1beta1(internalClient clientset.Interface) clientextensionsv1beta1.ExtensionsV1beta1Interface {
 	if internalClient == nil {
-		return &versionedclientset.Clientset{}
-	}
-	return &versionedclientset.Clientset{
-		CoreV1Client:            coreclientset.New(internalClient.Core().RESTClient()),
-		ExtensionsV1beta1Client: extensionsclientset.New(internalClient.Extensions().RESTClient()),
+		return &clientextensionsv1beta1.ExtensionsV1beta1Client{}
 	}
+	return clientextensionsv1beta1.New(internalClient.Extensions().RESTClient())
 }
 
 var maxAnnotationLen = 200
diff --git a/pkg/printers/internalversion/describe_test.go b/pkg/printers/internalversion/describe_test.go
index 9d9e8d99c27..2d74b242200 100644
--- a/pkg/printers/internalversion/describe_test.go
+++ b/pkg/printers/internalversion/describe_test.go
@@ -774,7 +774,7 @@ func TestDescribeDeployment(t *testing.T) {
 			},
 		},
 	})
-	d := DeploymentDescriber{fake, versionedFake}
+	d := DeploymentDescriber{fake, versionedFake.ExtensionsV1beta1()}
 	out, err := d.Describe("foo", "bar", printers.DescriberSettings{ShowEvents: true})
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -1267,7 +1267,7 @@ func TestDescribeEvents(t *testing.T) {
 					Replicas: utilpointer.Int32Ptr(1),
 					Selector: &metav1.LabelSelector{},
 				},
-			}),
+			}).ExtensionsV1beta1(),
 		},
 		"EndpointsDescriber": &EndpointsDescriber{
 			fake.NewSimpleClientset(&api.Endpoints{
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go
index 253f8523a5c..e178bd140a6 100644
--- a/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go
+++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go
@@ -184,10 +184,10 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget)
 	}
 
 	crdController := NewDiscoveryController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), versionDiscoveryHandler, groupDiscoveryHandler, c.GenericConfig.RequestContextMapper)
-	namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient)
+	namingController := status.NewNamingConditionController(s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(), crdClient.Apiextensions())
 	finalizingController := finalizer.NewCRDFinalizer(
 		s.Informers.Apiextensions().InternalVersion().CustomResourceDefinitions(),
-		crdClient,
+		crdClient.Apiextensions(),
 		crdHandler,
 	)
 
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go
index 0fb66d22e2d..bae98c78bf3 100644
--- a/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go
+++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/clientset.go
@@ -35,18 +35,18 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*apiextensionsv1beta1.ApiextensionsV1beta1Client
+	apiextensionsV1beta1 *apiextensionsv1beta1.ApiextensionsV1beta1Client
 }
 
 // ApiextensionsV1beta1 retrieves the ApiextensionsV1beta1Client
 func (c *Clientset) ApiextensionsV1beta1() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
-	return c.ApiextensionsV1beta1Client
+	return c.apiextensionsV1beta1
 }
 
 // Deprecated: Apiextensions retrieves the default version of ApiextensionsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Apiextensions() apiextensionsv1beta1.ApiextensionsV1beta1Interface {
-	return c.ApiextensionsV1beta1Client
+	return c.apiextensionsV1beta1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.ApiextensionsV1beta1Client, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy)
+	cs.apiextensionsV1beta1, err = apiextensionsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.NewForConfigOrDie(c)
+	cs.apiextensionsV1beta1 = apiextensionsv1beta1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.ApiextensionsV1beta1Client = apiextensionsv1beta1.New(c)
+	cs.apiextensionsV1beta1 = apiextensionsv1beta1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset/clientset.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset/clientset.go
index 1037f476e32..72803e76923 100644
--- a/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset/clientset.go
+++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/client/clientset/internalclientset/clientset.go
@@ -33,12 +33,12 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*apiextensionsinternalversion.ApiextensionsClient
+	apiextensions *apiextensionsinternalversion.ApiextensionsClient
 }
 
 // Apiextensions retrieves the ApiextensionsClient
 func (c *Clientset) Apiextensions() apiextensionsinternalversion.ApiextensionsInterface {
-	return c.ApiextensionsClient
+	return c.apiextensions
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.ApiextensionsClient, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy)
+	cs.apiextensions, err = apiextensionsinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.ApiextensionsClient = apiextensionsinternalversion.NewForConfigOrDie(c)
+	cs.apiextensions = apiextensionsinternalversion.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.ApiextensionsClient = apiextensionsinternalversion.New(c)
+	cs.apiextensions = apiextensionsinternalversion.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/client-go/kubernetes/clientset.go b/staging/src/k8s.io/client-go/kubernetes/clientset.go
index 8eeef78c2a7..a22cf6534fe 100644
--- a/staging/src/k8s.io/client-go/kubernetes/clientset.go
+++ b/staging/src/k8s.io/client-go/kubernetes/clientset.go
@@ -105,228 +105,228 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client
-	*appsv1beta1.AppsV1beta1Client
-	*appsv1beta2.AppsV1beta2Client
-	*authenticationv1.AuthenticationV1Client
-	*authenticationv1beta1.AuthenticationV1beta1Client
-	*authorizationv1.AuthorizationV1Client
-	*authorizationv1beta1.AuthorizationV1beta1Client
-	*autoscalingv1.AutoscalingV1Client
-	*autoscalingv2alpha1.AutoscalingV2alpha1Client
-	*batchv1.BatchV1Client
-	*batchv2alpha1.BatchV2alpha1Client
-	*certificatesv1beta1.CertificatesV1beta1Client
-	*corev1.CoreV1Client
-	*extensionsv1beta1.ExtensionsV1beta1Client
-	*networkingv1.NetworkingV1Client
-	*policyv1beta1.PolicyV1beta1Client
-	*rbacv1beta1.RbacV1beta1Client
-	*rbacv1alpha1.RbacV1alpha1Client
-	*schedulingv1alpha1.SchedulingV1alpha1Client
-	*settingsv1alpha1.SettingsV1alpha1Client
-	*storagev1beta1.StorageV1beta1Client
-	*storagev1.StorageV1Client
+	admissionregistrationV1alpha1 *admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Client
+	appsV1beta1                   *appsv1beta1.AppsV1beta1Client
+	appsV1beta2                   *appsv1beta2.AppsV1beta2Client
+	authenticationV1              *authenticationv1.AuthenticationV1Client
+	authenticationV1beta1         *authenticationv1beta1.AuthenticationV1beta1Client
+	authorizationV1               *authorizationv1.AuthorizationV1Client
+	authorizationV1beta1          *authorizationv1beta1.AuthorizationV1beta1Client
+	autoscalingV1                 *autoscalingv1.AutoscalingV1Client
+	autoscalingV2alpha1           *autoscalingv2alpha1.AutoscalingV2alpha1Client
+	batchV1                       *batchv1.BatchV1Client
+	batchV2alpha1                 *batchv2alpha1.BatchV2alpha1Client
+	certificatesV1beta1           *certificatesv1beta1.CertificatesV1beta1Client
+	coreV1                        *corev1.CoreV1Client
+	extensionsV1beta1             *extensionsv1beta1.ExtensionsV1beta1Client
+	networkingV1                  *networkingv1.NetworkingV1Client
+	policyV1beta1                 *policyv1beta1.PolicyV1beta1Client
+	rbacV1beta1                   *rbacv1beta1.RbacV1beta1Client
+	rbacV1alpha1                  *rbacv1alpha1.RbacV1alpha1Client
+	schedulingV1alpha1            *schedulingv1alpha1.SchedulingV1alpha1Client
+	settingsV1alpha1              *settingsv1alpha1.SettingsV1alpha1Client
+	storageV1beta1                *storagev1beta1.StorageV1beta1Client
+	storageV1                     *storagev1.StorageV1Client
 }
 
 // AdmissionregistrationV1alpha1 retrieves the AdmissionregistrationV1alpha1Client
 func (c *Clientset) AdmissionregistrationV1alpha1() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
-	return c.AdmissionregistrationV1alpha1Client
+	return c.admissionregistrationV1alpha1
 }
 
 // Deprecated: Admissionregistration retrieves the default version of AdmissionregistrationClient.
 // Please explicitly pick a version.
 func (c *Clientset) Admissionregistration() admissionregistrationv1alpha1.AdmissionregistrationV1alpha1Interface {
-	return c.AdmissionregistrationV1alpha1Client
+	return c.admissionregistrationV1alpha1
 }
 
 // AppsV1beta1 retrieves the AppsV1beta1Client
 func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
-	return c.AppsV1beta1Client
+	return c.appsV1beta1
 }
 
 // AppsV1beta2 retrieves the AppsV1beta2Client
 func (c *Clientset) AppsV1beta2() appsv1beta2.AppsV1beta2Interface {
-	return c.AppsV1beta2Client
+	return c.appsV1beta2
 }
 
 // Deprecated: Apps retrieves the default version of AppsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Apps() appsv1beta2.AppsV1beta2Interface {
-	return c.AppsV1beta2Client
+	return c.appsV1beta2
 }
 
 // AuthenticationV1 retrieves the AuthenticationV1Client
 func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
-	return c.AuthenticationV1Client
+	return c.authenticationV1
 }
 
 // Deprecated: Authentication retrieves the default version of AuthenticationClient.
 // Please explicitly pick a version.
 func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface {
-	return c.AuthenticationV1Client
+	return c.authenticationV1
 }
 
 // AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client
 func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
-	return c.AuthenticationV1beta1Client
+	return c.authenticationV1beta1
 }
 
 // AuthorizationV1 retrieves the AuthorizationV1Client
 func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
-	return c.AuthorizationV1Client
+	return c.authorizationV1
 }
 
 // Deprecated: Authorization retrieves the default version of AuthorizationClient.
 // Please explicitly pick a version.
 func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface {
-	return c.AuthorizationV1Client
+	return c.authorizationV1
 }
 
 // AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
 func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
-	return c.AuthorizationV1beta1Client
+	return c.authorizationV1beta1
 }
 
 // AutoscalingV1 retrieves the AutoscalingV1Client
 func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
-	return c.AutoscalingV1Client
+	return c.autoscalingV1
 }
 
 // Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
 // Please explicitly pick a version.
 func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
-	return c.AutoscalingV1Client
+	return c.autoscalingV1
 }
 
 // AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client
 func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface {
-	return c.AutoscalingV2alpha1Client
+	return c.autoscalingV2alpha1
 }
 
 // BatchV1 retrieves the BatchV1Client
 func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
-	return c.BatchV1Client
+	return c.batchV1
 }
 
 // Deprecated: Batch retrieves the default version of BatchClient.
 // Please explicitly pick a version.
 func (c *Clientset) Batch() batchv1.BatchV1Interface {
-	return c.BatchV1Client
+	return c.batchV1
 }
 
 // BatchV2alpha1 retrieves the BatchV2alpha1Client
 func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
-	return c.BatchV2alpha1Client
+	return c.batchV2alpha1
 }
 
 // CertificatesV1beta1 retrieves the CertificatesV1beta1Client
 func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
-	return c.CertificatesV1beta1Client
+	return c.certificatesV1beta1
 }
 
 // Deprecated: Certificates retrieves the default version of CertificatesClient.
 // Please explicitly pick a version.
 func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface {
-	return c.CertificatesV1beta1Client
+	return c.certificatesV1beta1
 }
 
 // CoreV1 retrieves the CoreV1Client
 func (c *Clientset) CoreV1() corev1.CoreV1Interface {
-	return c.CoreV1Client
+	return c.coreV1
 }
 
 // Deprecated: Core retrieves the default version of CoreClient.
 // Please explicitly pick a version.
 func (c *Clientset) Core() corev1.CoreV1Interface {
-	return c.CoreV1Client
+	return c.coreV1
 }
 
 // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
 func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return c.ExtensionsV1beta1Client
+	return c.extensionsV1beta1
 }
 
 // Deprecated: Extensions retrieves the default version of ExtensionsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return c.ExtensionsV1beta1Client
+	return c.extensionsV1beta1
 }
 
 // NetworkingV1 retrieves the NetworkingV1Client
 func (c *Clientset) NetworkingV1() networkingv1.NetworkingV1Interface {
-	return c.NetworkingV1Client
+	return c.networkingV1
 }
 
 // Deprecated: Networking retrieves the default version of NetworkingClient.
 // Please explicitly pick a version.
 func (c *Clientset) Networking() networkingv1.NetworkingV1Interface {
-	return c.NetworkingV1Client
+	return c.networkingV1
 }
 
 // PolicyV1beta1 retrieves the PolicyV1beta1Client
 func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
-	return c.PolicyV1beta1Client
+	return c.policyV1beta1
 }
 
 // Deprecated: Policy retrieves the default version of PolicyClient.
 // Please explicitly pick a version.
 func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface {
-	return c.PolicyV1beta1Client
+	return c.policyV1beta1
 }
 
 // RbacV1beta1 retrieves the RbacV1beta1Client
 func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
-	return c.RbacV1beta1Client
+	return c.rbacV1beta1
 }
 
 // Deprecated: Rbac retrieves the default version of RbacClient.
 // Please explicitly pick a version.
 func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface {
-	return c.RbacV1beta1Client
+	return c.rbacV1beta1
 }
 
 // RbacV1alpha1 retrieves the RbacV1alpha1Client
 func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
-	return c.RbacV1alpha1Client
+	return c.rbacV1alpha1
 }
 
 // SchedulingV1alpha1 retrieves the SchedulingV1alpha1Client
 func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface {
-	return c.SchedulingV1alpha1Client
+	return c.schedulingV1alpha1
 }
 
 // Deprecated: Scheduling retrieves the default version of SchedulingClient.
 // Please explicitly pick a version.
 func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface {
-	return c.SchedulingV1alpha1Client
+	return c.schedulingV1alpha1
 }
 
 // SettingsV1alpha1 retrieves the SettingsV1alpha1Client
 func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface {
-	return c.SettingsV1alpha1Client
+	return c.settingsV1alpha1
 }
 
 // Deprecated: Settings retrieves the default version of SettingsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface {
-	return c.SettingsV1alpha1Client
+	return c.settingsV1alpha1
 }
 
 // StorageV1beta1 retrieves the StorageV1beta1Client
 func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
-	return c.StorageV1beta1Client
+	return c.storageV1beta1
 }
 
 // StorageV1 retrieves the StorageV1Client
 func (c *Clientset) StorageV1() storagev1.StorageV1Interface {
-	return c.StorageV1Client
+	return c.storageV1
 }
 
 // Deprecated: Storage retrieves the default version of StorageClient.
 // Please explicitly pick a version.
 func (c *Clientset) Storage() storagev1.StorageV1Interface {
-	return c.StorageV1Client
+	return c.storageV1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -345,91 +345,91 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.AdmissionregistrationV1alpha1Client, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy)
+	cs.admissionregistrationV1alpha1, err = admissionregistrationv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AppsV1beta1Client, err = appsv1beta1.NewForConfig(&configShallowCopy)
+	cs.appsV1beta1, err = appsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AppsV1beta2Client, err = appsv1beta2.NewForConfig(&configShallowCopy)
+	cs.appsV1beta2, err = appsv1beta2.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthenticationV1Client, err = authenticationv1.NewForConfig(&configShallowCopy)
+	cs.authenticationV1, err = authenticationv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthenticationV1beta1Client, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
+	cs.authenticationV1beta1, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthorizationV1Client, err = authorizationv1.NewForConfig(&configShallowCopy)
+	cs.authorizationV1, err = authorizationv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthorizationV1beta1Client, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
+	cs.authorizationV1beta1, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy)
+	cs.autoscalingV1, err = autoscalingv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AutoscalingV2alpha1Client, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
+	cs.autoscalingV2alpha1, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy)
+	cs.batchV1, err = batchv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchV2alpha1Client, err = batchv2alpha1.NewForConfig(&configShallowCopy)
+	cs.batchV2alpha1, err = batchv2alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CertificatesV1beta1Client, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
+	cs.certificatesV1beta1, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy)
+	cs.coreV1, err = corev1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
+	cs.extensionsV1beta1, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.NetworkingV1Client, err = networkingv1.NewForConfig(&configShallowCopy)
+	cs.networkingV1, err = networkingv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.PolicyV1beta1Client, err = policyv1beta1.NewForConfig(&configShallowCopy)
+	cs.policyV1beta1, err = policyv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.RbacV1beta1Client, err = rbacv1beta1.NewForConfig(&configShallowCopy)
+	cs.rbacV1beta1, err = rbacv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.RbacV1alpha1Client, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
+	cs.rbacV1alpha1, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.SchedulingV1alpha1Client, err = schedulingv1alpha1.NewForConfig(&configShallowCopy)
+	cs.schedulingV1alpha1, err = schedulingv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.SettingsV1alpha1Client, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
+	cs.settingsV1alpha1, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.StorageV1beta1Client, err = storagev1beta1.NewForConfig(&configShallowCopy)
+	cs.storageV1beta1, err = storagev1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.StorageV1Client, err = storagev1.NewForConfig(&configShallowCopy)
+	cs.storageV1, err = storagev1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -446,28 +446,28 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.NewForConfigOrDie(c)
-	cs.AppsV1beta1Client = appsv1beta1.NewForConfigOrDie(c)
-	cs.AppsV1beta2Client = appsv1beta2.NewForConfigOrDie(c)
-	cs.AuthenticationV1Client = authenticationv1.NewForConfigOrDie(c)
-	cs.AuthenticationV1beta1Client = authenticationv1beta1.NewForConfigOrDie(c)
-	cs.AuthorizationV1Client = authorizationv1.NewForConfigOrDie(c)
-	cs.AuthorizationV1beta1Client = authorizationv1beta1.NewForConfigOrDie(c)
-	cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c)
-	cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.NewForConfigOrDie(c)
-	cs.BatchV1Client = batchv1.NewForConfigOrDie(c)
-	cs.BatchV2alpha1Client = batchv2alpha1.NewForConfigOrDie(c)
-	cs.CertificatesV1beta1Client = certificatesv1beta1.NewForConfigOrDie(c)
-	cs.CoreV1Client = corev1.NewForConfigOrDie(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c)
-	cs.NetworkingV1Client = networkingv1.NewForConfigOrDie(c)
-	cs.PolicyV1beta1Client = policyv1beta1.NewForConfigOrDie(c)
-	cs.RbacV1beta1Client = rbacv1beta1.NewForConfigOrDie(c)
-	cs.RbacV1alpha1Client = rbacv1alpha1.NewForConfigOrDie(c)
-	cs.SchedulingV1alpha1Client = schedulingv1alpha1.NewForConfigOrDie(c)
-	cs.SettingsV1alpha1Client = settingsv1alpha1.NewForConfigOrDie(c)
-	cs.StorageV1beta1Client = storagev1beta1.NewForConfigOrDie(c)
-	cs.StorageV1Client = storagev1.NewForConfigOrDie(c)
+	cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.NewForConfigOrDie(c)
+	cs.appsV1beta1 = appsv1beta1.NewForConfigOrDie(c)
+	cs.appsV1beta2 = appsv1beta2.NewForConfigOrDie(c)
+	cs.authenticationV1 = authenticationv1.NewForConfigOrDie(c)
+	cs.authenticationV1beta1 = authenticationv1beta1.NewForConfigOrDie(c)
+	cs.authorizationV1 = authorizationv1.NewForConfigOrDie(c)
+	cs.authorizationV1beta1 = authorizationv1beta1.NewForConfigOrDie(c)
+	cs.autoscalingV1 = autoscalingv1.NewForConfigOrDie(c)
+	cs.autoscalingV2alpha1 = autoscalingv2alpha1.NewForConfigOrDie(c)
+	cs.batchV1 = batchv1.NewForConfigOrDie(c)
+	cs.batchV2alpha1 = batchv2alpha1.NewForConfigOrDie(c)
+	cs.certificatesV1beta1 = certificatesv1beta1.NewForConfigOrDie(c)
+	cs.coreV1 = corev1.NewForConfigOrDie(c)
+	cs.extensionsV1beta1 = extensionsv1beta1.NewForConfigOrDie(c)
+	cs.networkingV1 = networkingv1.NewForConfigOrDie(c)
+	cs.policyV1beta1 = policyv1beta1.NewForConfigOrDie(c)
+	cs.rbacV1beta1 = rbacv1beta1.NewForConfigOrDie(c)
+	cs.rbacV1alpha1 = rbacv1alpha1.NewForConfigOrDie(c)
+	cs.schedulingV1alpha1 = schedulingv1alpha1.NewForConfigOrDie(c)
+	cs.settingsV1alpha1 = settingsv1alpha1.NewForConfigOrDie(c)
+	cs.storageV1beta1 = storagev1beta1.NewForConfigOrDie(c)
+	cs.storageV1 = storagev1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -476,28 +476,28 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.AdmissionregistrationV1alpha1Client = admissionregistrationv1alpha1.New(c)
-	cs.AppsV1beta1Client = appsv1beta1.New(c)
-	cs.AppsV1beta2Client = appsv1beta2.New(c)
-	cs.AuthenticationV1Client = authenticationv1.New(c)
-	cs.AuthenticationV1beta1Client = authenticationv1beta1.New(c)
-	cs.AuthorizationV1Client = authorizationv1.New(c)
-	cs.AuthorizationV1beta1Client = authorizationv1beta1.New(c)
-	cs.AutoscalingV1Client = autoscalingv1.New(c)
-	cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.New(c)
-	cs.BatchV1Client = batchv1.New(c)
-	cs.BatchV2alpha1Client = batchv2alpha1.New(c)
-	cs.CertificatesV1beta1Client = certificatesv1beta1.New(c)
-	cs.CoreV1Client = corev1.New(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c)
-	cs.NetworkingV1Client = networkingv1.New(c)
-	cs.PolicyV1beta1Client = policyv1beta1.New(c)
-	cs.RbacV1beta1Client = rbacv1beta1.New(c)
-	cs.RbacV1alpha1Client = rbacv1alpha1.New(c)
-	cs.SchedulingV1alpha1Client = schedulingv1alpha1.New(c)
-	cs.SettingsV1alpha1Client = settingsv1alpha1.New(c)
-	cs.StorageV1beta1Client = storagev1beta1.New(c)
-	cs.StorageV1Client = storagev1.New(c)
+	cs.admissionregistrationV1alpha1 = admissionregistrationv1alpha1.New(c)
+	cs.appsV1beta1 = appsv1beta1.New(c)
+	cs.appsV1beta2 = appsv1beta2.New(c)
+	cs.authenticationV1 = authenticationv1.New(c)
+	cs.authenticationV1beta1 = authenticationv1beta1.New(c)
+	cs.authorizationV1 = authorizationv1.New(c)
+	cs.authorizationV1beta1 = authorizationv1beta1.New(c)
+	cs.autoscalingV1 = autoscalingv1.New(c)
+	cs.autoscalingV2alpha1 = autoscalingv2alpha1.New(c)
+	cs.batchV1 = batchv1.New(c)
+	cs.batchV2alpha1 = batchv2alpha1.New(c)
+	cs.certificatesV1beta1 = certificatesv1beta1.New(c)
+	cs.coreV1 = corev1.New(c)
+	cs.extensionsV1beta1 = extensionsv1beta1.New(c)
+	cs.networkingV1 = networkingv1.New(c)
+	cs.policyV1beta1 = policyv1beta1.New(c)
+	cs.rbacV1beta1 = rbacv1beta1.New(c)
+	cs.rbacV1alpha1 = rbacv1alpha1.New(c)
+	cs.schedulingV1alpha1 = schedulingv1alpha1.New(c)
+	cs.settingsV1alpha1 = settingsv1alpha1.New(c)
+	cs.storageV1beta1 = storagev1beta1.New(c)
+	cs.storageV1 = storagev1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go b/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go
index 3bc61ba394b..2770ab732a9 100644
--- a/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go
+++ b/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/clientset.go
@@ -35,18 +35,18 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*apiregistrationv1beta1.ApiregistrationV1beta1Client
+	apiregistrationV1beta1 *apiregistrationv1beta1.ApiregistrationV1beta1Client
 }
 
 // ApiregistrationV1beta1 retrieves the ApiregistrationV1beta1Client
 func (c *Clientset) ApiregistrationV1beta1() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
-	return c.ApiregistrationV1beta1Client
+	return c.apiregistrationV1beta1
 }
 
 // Deprecated: Apiregistration retrieves the default version of ApiregistrationClient.
 // Please explicitly pick a version.
 func (c *Clientset) Apiregistration() apiregistrationv1beta1.ApiregistrationV1beta1Interface {
-	return c.ApiregistrationV1beta1Client
+	return c.apiregistrationV1beta1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.ApiregistrationV1beta1Client, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy)
+	cs.apiregistrationV1beta1, err = apiregistrationv1beta1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.NewForConfigOrDie(c)
+	cs.apiregistrationV1beta1 = apiregistrationv1beta1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.ApiregistrationV1beta1Client = apiregistrationv1beta1.New(c)
+	cs.apiregistrationV1beta1 = apiregistrationv1beta1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/internalclientset/clientset.go b/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/internalclientset/clientset.go
index 92a3ecb252b..1c16da25441 100644
--- a/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/internalclientset/clientset.go
+++ b/staging/src/k8s.io/kube-aggregator/pkg/client/clientset_generated/internalclientset/clientset.go
@@ -33,12 +33,12 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*apiregistrationinternalversion.ApiregistrationClient
+	apiregistration *apiregistrationinternalversion.ApiregistrationClient
 }
 
 // Apiregistration retrieves the ApiregistrationClient
 func (c *Clientset) Apiregistration() apiregistrationinternalversion.ApiregistrationInterface {
-	return c.ApiregistrationClient
+	return c.apiregistration
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.ApiregistrationClient, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy)
+	cs.apiregistration, err = apiregistrationinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.ApiregistrationClient = apiregistrationinternalversion.NewForConfigOrDie(c)
+	cs.apiregistration = apiregistrationinternalversion.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.ApiregistrationClient = apiregistrationinternalversion.New(c)
+	cs.apiregistration = apiregistrationinternalversion.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/kube-gen/cmd/client-gen/generators/generator_for_clientset.go b/staging/src/k8s.io/kube-gen/cmd/client-gen/generators/generator_for_clientset.go
index 1897635a816..174cb65cb78 100644
--- a/staging/src/k8s.io/kube-gen/cmd/client-gen/generators/generator_for_clientset.go
+++ b/staging/src/k8s.io/kube-gen/cmd/client-gen/generators/generator_for_clientset.go
@@ -70,7 +70,6 @@ func (g *genClientset) GenerateType(c *generator.Context, t *types.Type, w io.Wr
 	sw := generator.NewSnippetWriter(w, c, "$", "$")
 
 	allGroups := clientgentypes.ToGroupVersionPackages(g.groups)
-
 	m := map[string]interface{}{
 		"allGroups":                            allGroups,
 		"Config":                               c.Universe.Type(types.Name{Package: "k8s.io/client-go/rest", Name: "Config"}),
@@ -116,7 +115,7 @@ var clientsetTemplate = `
 // version included in a Clientset.
 type Clientset struct {
 	*$.DiscoveryClient|raw$
-    $range .allGroups$*$.PackageName$.$.GroupVersion$Client
+    $range .allGroups$$.LowerCaseGroupVersion$ *$.PackageName$.$.GroupVersion$Client
     $end$
 }
 `
@@ -124,7 +123,7 @@ type Clientset struct {
 var clientsetInterfaceImplTemplate = `
 // $.GroupVersion$ retrieves the $.GroupVersion$Client
 func (c *Clientset) $.GroupVersion$() $.PackageName$.$.GroupVersion$Interface {
-	return c.$.GroupVersion$Client
+	return c.$.LowerCaseGroupVersion$
 }
 `
 
@@ -132,7 +131,7 @@ var clientsetInterfaceDefaultVersionImpl = `
 // Deprecated: $.Group$ retrieves the default version of $.Group$Client.
 // Please explicitly pick a version.
 func (c *Clientset) $.Group$() $.PackageName$.$.GroupVersion$Interface {
-	return c.$.GroupVersion$Client
+	return c.$.LowerCaseGroupVersion$
 }
 `
 
@@ -155,7 +154,7 @@ func NewForConfig(c *$.Config|raw$) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-$range .allGroups$    cs.$.GroupVersion$Client, err =$.PackageName$.NewForConfig(&configShallowCopy)
+$range .allGroups$    cs.$.LowerCaseGroupVersion$, err =$.PackageName$.NewForConfig(&configShallowCopy)
 	if err!=nil {
 		return nil, err
 	}
@@ -174,7 +173,7 @@ var newClientsetForConfigOrDieTemplate = `
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *$.Config|raw$) *Clientset {
 	var cs Clientset
-$range .allGroups$    cs.$.GroupVersion$Client =$.PackageName$.NewForConfigOrDie(c)
+$range .allGroups$    cs.$.LowerCaseGroupVersion$ =$.PackageName$.NewForConfigOrDie(c)
 $end$
 	cs.DiscoveryClient = $.NewDiscoveryClientForConfigOrDie|raw$(c)
 	return &cs
@@ -185,7 +184,7 @@ var newClientsetForRESTClientTemplate = `
 // New creates a new Clientset for the given RESTClient.
 func New(c $.RESTClientInterface|raw$) *Clientset {
 	var cs Clientset
-$range .allGroups$    cs.$.GroupVersion$Client =$.PackageName$.New(c)
+$range .allGroups$    cs.$.LowerCaseGroupVersion$ =$.PackageName$.New(c)
 $end$
 	cs.DiscoveryClient = $.NewDiscoveryClient|raw$(c)
 	return &cs
diff --git a/staging/src/k8s.io/kube-gen/cmd/client-gen/types/helpers.go b/staging/src/k8s.io/kube-gen/cmd/client-gen/types/helpers.go
index 618a0737ae3..b9f4730e227 100644
--- a/staging/src/k8s.io/kube-gen/cmd/client-gen/types/helpers.go
+++ b/staging/src/k8s.io/kube-gen/cmd/client-gen/types/helpers.go
@@ -91,11 +91,12 @@ func ToGroupVersionPackages(groups []GroupVersions) []GroupVersionPackage {
 		defaultVersion := defaultVersion(group.Versions)
 		for _, version := range group.Versions {
 			groupVersionPackages = append(groupVersionPackages, GroupVersionPackage{
-				Group:            Group(namer.IC(group.Group.NonEmpty())),
-				Version:          Version(namer.IC(version.String())),
-				GroupVersion:     namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()),
-				PackageName:      strings.ToLower(group.Group.NonEmpty() + version.NonEmpty()),
-				IsDefaultVersion: version == defaultVersion && version != "",
+				Group:                 Group(namer.IC(group.Group.NonEmpty())),
+				Version:               Version(namer.IC(version.String())),
+				GroupVersion:          namer.IC(group.Group.NonEmpty()) + namer.IC(version.String()),
+				LowerCaseGroupVersion: namer.IL(group.Group.NonEmpty()) + namer.IC(version.String()),
+				PackageName:           strings.ToLower(group.Group.NonEmpty() + version.NonEmpty()),
+				IsDefaultVersion:      version == defaultVersion && version != "",
 			})
 		}
 	}
diff --git a/staging/src/k8s.io/kube-gen/cmd/client-gen/types/types.go b/staging/src/k8s.io/kube-gen/cmd/client-gen/types/types.go
index 135ea5a2423..c20b221c307 100644
--- a/staging/src/k8s.io/kube-gen/cmd/client-gen/types/types.go
+++ b/staging/src/k8s.io/kube-gen/cmd/client-gen/types/types.go
@@ -58,9 +58,10 @@ type GroupVersionPackage struct {
 	Version Version
 	// If a user calls a group client without specifying the version (e.g.,
 	// c.Core(), instead of c.CoreV1()), the default version will be returned.
-	IsDefaultVersion bool
-	GroupVersion     string
-	PackageName      string
+	IsDefaultVersion      bool
+	GroupVersion          string
+	LowerCaseGroupVersion string
+	PackageName           string
 }
 
 type GroupInstallPackage struct {
diff --git a/staging/src/k8s.io/kube-gen/test/clientset/internal/clientset.go b/staging/src/k8s.io/kube-gen/test/clientset/internal/clientset.go
index a5582812224..2046acba1ce 100644
--- a/staging/src/k8s.io/kube-gen/test/clientset/internal/clientset.go
+++ b/staging/src/k8s.io/kube-gen/test/clientset/internal/clientset.go
@@ -33,12 +33,12 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*testgroupinternalversion.TestgroupClient
+	testgroup *testgroupinternalversion.TestgroupClient
 }
 
 // Testgroup retrieves the TestgroupClient
 func (c *Clientset) Testgroup() testgroupinternalversion.TestgroupInterface {
-	return c.TestgroupClient
+	return c.testgroup
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.TestgroupClient, err = testgroupinternalversion.NewForConfig(&configShallowCopy)
+	cs.testgroup, err = testgroupinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.TestgroupClient = testgroupinternalversion.NewForConfigOrDie(c)
+	cs.testgroup = testgroupinternalversion.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.TestgroupClient = testgroupinternalversion.New(c)
+	cs.testgroup = testgroupinternalversion.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/kube-gen/test/clientset/versioned/clientset.go b/staging/src/k8s.io/kube-gen/test/clientset/versioned/clientset.go
index 9a5615393a3..709bb6418e3 100644
--- a/staging/src/k8s.io/kube-gen/test/clientset/versioned/clientset.go
+++ b/staging/src/k8s.io/kube-gen/test/clientset/versioned/clientset.go
@@ -35,18 +35,18 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*testgroupv1.TestgroupV1Client
+	testgroupV1 *testgroupv1.TestgroupV1Client
 }
 
 // TestgroupV1 retrieves the TestgroupV1Client
 func (c *Clientset) TestgroupV1() testgroupv1.TestgroupV1Interface {
-	return c.TestgroupV1Client
+	return c.testgroupV1
 }
 
 // Deprecated: Testgroup retrieves the default version of TestgroupClient.
 // Please explicitly pick a version.
 func (c *Clientset) Testgroup() testgroupv1.TestgroupV1Interface {
-	return c.TestgroupV1Client
+	return c.testgroupV1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.TestgroupV1Client, err = testgroupv1.NewForConfig(&configShallowCopy)
+	cs.testgroupV1, err = testgroupv1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.TestgroupV1Client = testgroupv1.NewForConfigOrDie(c)
+	cs.testgroupV1 = testgroupv1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.TestgroupV1Client = testgroupv1.New(c)
+	cs.testgroupV1 = testgroupv1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset/clientset.go b/staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset/clientset.go
index e0f4eda4fd7..5d8f8ac492e 100644
--- a/staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset/clientset.go
+++ b/staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset/clientset.go
@@ -35,18 +35,18 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*metricsv1alpha1.MetricsV1alpha1Client
+	metricsV1alpha1 *metricsv1alpha1.MetricsV1alpha1Client
 }
 
 // MetricsV1alpha1 retrieves the MetricsV1alpha1Client
 func (c *Clientset) MetricsV1alpha1() metricsv1alpha1.MetricsV1alpha1Interface {
-	return c.MetricsV1alpha1Client
+	return c.metricsV1alpha1
 }
 
 // Deprecated: Metrics retrieves the default version of MetricsClient.
 // Please explicitly pick a version.
 func (c *Clientset) Metrics() metricsv1alpha1.MetricsV1alpha1Interface {
-	return c.MetricsV1alpha1Client
+	return c.metricsV1alpha1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.MetricsV1alpha1Client, err = metricsv1alpha1.NewForConfig(&configShallowCopy)
+	cs.metricsV1alpha1, err = metricsv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.MetricsV1alpha1Client = metricsv1alpha1.NewForConfigOrDie(c)
+	cs.metricsV1alpha1 = metricsv1alpha1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.MetricsV1alpha1Client = metricsv1alpha1.New(c)
+	cs.metricsV1alpha1 = metricsv1alpha1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/clientset/clientset.go b/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/clientset/clientset.go
index bcafdadaedf..1d5a42d894b 100644
--- a/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/clientset/clientset.go
+++ b/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/clientset/clientset.go
@@ -35,18 +35,18 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*wardlev1alpha1.WardleV1alpha1Client
+	wardleV1alpha1 *wardlev1alpha1.WardleV1alpha1Client
 }
 
 // WardleV1alpha1 retrieves the WardleV1alpha1Client
 func (c *Clientset) WardleV1alpha1() wardlev1alpha1.WardleV1alpha1Interface {
-	return c.WardleV1alpha1Client
+	return c.wardleV1alpha1
 }
 
 // Deprecated: Wardle retrieves the default version of WardleClient.
 // Please explicitly pick a version.
 func (c *Clientset) Wardle() wardlev1alpha1.WardleV1alpha1Interface {
-	return c.WardleV1alpha1Client
+	return c.wardleV1alpha1
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -65,7 +65,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.WardleV1alpha1Client, err = wardlev1alpha1.NewForConfig(&configShallowCopy)
+	cs.wardleV1alpha1, err = wardlev1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -82,7 +82,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.WardleV1alpha1Client = wardlev1alpha1.NewForConfigOrDie(c)
+	cs.wardleV1alpha1 = wardlev1alpha1.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -91,7 +91,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.WardleV1alpha1Client = wardlev1alpha1.New(c)
+	cs.wardleV1alpha1 = wardlev1alpha1.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/internalclientset/clientset.go b/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/internalclientset/clientset.go
index b96b1664467..52122a75a8f 100644
--- a/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/internalclientset/clientset.go
+++ b/staging/src/k8s.io/sample-apiserver/pkg/client/clientset_generated/internalclientset/clientset.go
@@ -33,12 +33,12 @@ type Interface interface {
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*wardleinternalversion.WardleClient
+	wardle *wardleinternalversion.WardleClient
 }
 
 // Wardle retrieves the WardleClient
 func (c *Clientset) Wardle() wardleinternalversion.WardleInterface {
-	return c.WardleClient
+	return c.wardle
 }
 
 // Discovery retrieves the DiscoveryClient
@@ -57,7 +57,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	}
 	var cs Clientset
 	var err error
-	cs.WardleClient, err = wardleinternalversion.NewForConfig(&configShallowCopy)
+	cs.wardle, err = wardleinternalversion.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +74,7 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
 	var cs Clientset
-	cs.WardleClient = wardleinternalversion.NewForConfigOrDie(c)
+	cs.wardle = wardleinternalversion.NewForConfigOrDie(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
 	return &cs
@@ -83,7 +83,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
 	var cs Clientset
-	cs.WardleClient = wardleinternalversion.New(c)
+	cs.wardle = wardleinternalversion.New(c)
 
 	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
 	return &cs
diff --git a/test/e2e/apps/deployment.go b/test/e2e/apps/deployment.go
index 6434fa0160d..96815ebb8e6 100644
--- a/test/e2e/apps/deployment.go
+++ b/test/e2e/apps/deployment.go
@@ -132,7 +132,7 @@ func failureTrap(c clientset.Interface, ns string) {
 		d := deployments.Items[i]
 
 		framework.Logf(spew.Sprintf("Deployment %q:\n%+v\n", d.Name, d))
-		_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(&d, c)
+		_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(&d, c.ExtensionsV1beta1())
 		if err != nil {
 			framework.Logf("Could not list ReplicaSets for Deployment %q: %v", d.Name, err)
 			return
@@ -186,7 +186,7 @@ func checkDeploymentRevision(c clientset.Interface, ns, deploymentName, revision
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
 	Expect(err).NotTo(HaveOccurred())
 	// Check revision of the new replica set of this deployment
-	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(newRS).NotTo(Equal(nilRs))
 	Expect(newRS.Annotations).NotTo(Equal(nil))
@@ -268,7 +268,7 @@ func testDeleteDeployment(f *framework.Framework) {
 
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
 	Expect(err).NotTo(HaveOccurred())
-	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(newRS).NotTo(Equal(nilRs))
 	stopDeployment(c, internalClient, ns, deploymentName)
@@ -318,7 +318,7 @@ func testRollingUpdateDeployment(f *framework.Framework) {
 	framework.Logf("Ensuring deployment %q has one old replica set (the one it adopted)", deploy.Name)
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
 	Expect(err).NotTo(HaveOccurred())
-	_, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c)
+	_, allOldRSs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(len(allOldRSs)).Should(Equal(1))
 	// The old RS should contain pod-template-hash in its selector, label, and template label
@@ -542,7 +542,7 @@ func testPausedDeployment(f *framework.Framework) {
 	Expect(err).NotTo(HaveOccurred())
 
 	// Verify that there is no latest state realized for the new deployment.
-	rs, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(rs).To(Equal(nilRs))
 
@@ -594,11 +594,11 @@ func testPausedDeployment(f *framework.Framework) {
 	Expect(err).NotTo(HaveOccurred())
 
 	framework.Logf("Looking for new replicaset for paused deployment %q (there should be none)", deploymentName)
-	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(newRS).To(Equal(nilRs))
 
-	_, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c)
+	_, allOldRs, err := deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	if len(allOldRs) != 1 {
 		err = fmt.Errorf("expected an old replica set")
@@ -887,7 +887,7 @@ func testDeploymentLabelAdopted(f *framework.Framework) {
 	// There should be no old RSs (overlapping RS)
 	deployment, err := c.Extensions().Deployments(ns).Get(deploymentName, metav1.GetOptions{})
 	Expect(err).NotTo(HaveOccurred())
-	oldRSs, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c)
+	oldRSs, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(len(oldRSs)).Should(Equal(0))
 	Expect(len(allOldRSs)).Should(Equal(0))
@@ -951,7 +951,7 @@ func testScalePausedDeployment(f *framework.Framework) {
 	err = framework.WaitForObservedDeployment(c, ns, deploymentName, deployment.Generation)
 	Expect(err).NotTo(HaveOccurred())
 
-	rs, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	Expect(*(rs.Spec.Replicas)).Should(Equal(newReplicas))
 }
@@ -985,7 +985,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 	framework.Logf("Waiting for deployment %q to complete", deployment.Name)
 	Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
 
-	first, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	first, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 
 	// Update the deployment with a non-existent image so that the new replica set will be blocked.
@@ -1007,7 +1007,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 	}
 
 	framework.Logf("Checking that the replica sets for %q are synced", deploymentName)
-	second, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	second, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 
 	first, err = c.Extensions().ReplicaSets(first.Namespace).Get(first.Name, metav1.GetOptions{})
@@ -1035,7 +1035,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 	framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment))
 	Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
 
-	oldRSs, _, rs, err := deploymentutil.GetAllReplicaSets(deployment, c)
+	oldRSs, _, rs, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 
 	for _, rs := range append(oldRSs, rs) {
@@ -1070,7 +1070,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 	oldRs, err := c.Extensions().ReplicaSets(rs.Namespace).Get(rs.Name, metav1.GetOptions{})
 	Expect(err).NotTo(HaveOccurred())
 
-	newRs, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 
 	oldCond := replicaSetHasDesiredReplicas(c.Extensions(), oldRs)
@@ -1095,7 +1095,7 @@ func testScaledRolloutDeployment(f *framework.Framework) {
 	framework.Logf("Waiting for deployment status to sync (current available: %d, minimum available: %d)", deployment.Status.AvailableReplicas, deploymentutil.MinAvailable(deployment))
 	Expect(framework.WaitForDeploymentStatusValid(c, deployment)).NotTo(HaveOccurred())
 
-	oldRSs, _, rs, err = deploymentutil.GetAllReplicaSets(deployment, c)
+	oldRSs, _, rs, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 
 	for _, rs := range append(oldRSs, rs) {
@@ -1433,7 +1433,7 @@ func testDeploymentHashCollisionAvoidance(f *framework.Framework) {
 	// once it has no owner reference, then recreate the Deployment if we ever proceed with
 	// https://github.com/kubernetes/kubernetes/issues/44237
 	framework.Logf("Mock a hash collision")
-	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	Expect(err).NotTo(HaveOccurred())
 	var nilRs *extensions.ReplicaSet
 	Expect(newRS).NotTo(Equal(nilRs))
diff --git a/test/e2e/apps/disruption.go b/test/e2e/apps/disruption.go
index f9dd59f4450..0a7db3b0557 100644
--- a/test/e2e/apps/disruption.go
+++ b/test/e2e/apps/disruption.go
@@ -163,7 +163,7 @@ var _ = SIGDescribe("DisruptionController", func() {
 			// Locate a running pod.
 			var pod v1.Pod
 			err := wait.PollImmediate(framework.Poll, schedulingTimeout, func() (bool, error) {
-				podList, err := cs.Pods(ns).List(metav1.ListOptions{})
+				podList, err := cs.CoreV1().Pods(ns).List(metav1.ListOptions{})
 				if err != nil {
 					return false, err
 				}
@@ -191,7 +191,7 @@ var _ = SIGDescribe("DisruptionController", func() {
 				// this gives the controller enough time to have truly set the status.
 				time.Sleep(timeout)
 
-				err = cs.Pods(ns).Evict(e)
+				err = cs.CoreV1().Pods(ns).Evict(e)
 				Expect(err).Should(MatchError("Cannot evict pod as it would violate the pod's disruption budget."))
 			} else {
 				// Only wait for running pods in the "allow" case
@@ -202,7 +202,7 @@ var _ = SIGDescribe("DisruptionController", func() {
 				// Since disruptionAllowed starts out false, if an eviction is ever allowed,
 				// that means the controller is working.
 				err = wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
-					err = cs.Pods(ns).Evict(e)
+					err = cs.CoreV1().Pods(ns).Evict(e)
 					if err != nil {
 						return false, nil
 					} else {
@@ -264,7 +264,7 @@ func createPodsOrDie(cs *kubernetes.Clientset, ns string, n int) {
 			},
 		}
 
-		_, err := cs.Pods(ns).Create(pod)
+		_, err := cs.CoreV1().Pods(ns).Create(pod)
 		framework.ExpectNoError(err, "Creating pod %q in namespace %q", pod.Name, ns)
 	}
 }
diff --git a/test/e2e/framework/deployment_util.go b/test/e2e/framework/deployment_util.go
index a8fcb77c4c5..e4da5014d9a 100644
--- a/test/e2e/framework/deployment_util.go
+++ b/test/e2e/framework/deployment_util.go
@@ -72,7 +72,7 @@ func WaitForDeploymentOldRSsNum(c clientset.Interface, ns, deploymentName string
 		}
 		d = deployment
 
-		_, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c)
+		_, oldRSs, err = deploymentutil.GetOldReplicaSets(deployment, c.ExtensionsV1beta1())
 		if err != nil {
 			return false, err
 		}
@@ -108,7 +108,7 @@ func WaitForDeploymentWithCondition(c clientset.Interface, ns, deploymentName, r
 	})
 	if pollErr == wait.ErrWaitTimeout {
 		pollErr = fmt.Errorf("deployment %q never updated with the desired condition and reason: %v", deployment.Name, deployment.Status.Conditions)
-		_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c)
+		_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 		if err == nil {
 			logReplicaSetsOfDeployment(deployment, allOldRSs, newRS)
 			logPodsOfDeployment(c, deployment, append(allOldRSs, newRS))
@@ -176,7 +176,7 @@ func WaitForDeploymentStatus(c clientset.Interface, d *extensions.Deployment) er
 		if err != nil {
 			return false, err
 		}
-		oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c)
+		oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 		if err != nil {
 			return false, err
 		}
@@ -276,8 +276,8 @@ func WatchRecreateDeployment(c clientset.Interface, d *extensions.Deployment) er
 		status = d.Status
 
 		if d.Status.UpdatedReplicas > 0 && d.Status.Replicas != d.Status.UpdatedReplicas {
-			_, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c)
-			newRS, nerr := deploymentutil.GetNewReplicaSet(d, c)
+			_, allOldRSs, err := deploymentutil.GetOldReplicaSets(d, c.ExtensionsV1beta1())
+			newRS, nerr := deploymentutil.GetNewReplicaSet(d, c.ExtensionsV1beta1())
 			if err == nil && nerr == nil {
 				Logf("%+v", d)
 				logReplicaSetsOfDeployment(d, allOldRSs, newRS)
diff --git a/test/e2e/framework/rs_util.go b/test/e2e/framework/rs_util.go
index 0b2907f6513..863a03bef5f 100644
--- a/test/e2e/framework/rs_util.go
+++ b/test/e2e/framework/rs_util.go
@@ -63,7 +63,7 @@ func CheckNewRSAnnotations(c clientset.Interface, ns, deploymentName string, exp
 	if err != nil {
 		return err
 	}
-	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	if err != nil {
 		return err
 	}
diff --git a/test/e2e/upgrades/apps/deployments.go b/test/e2e/upgrades/apps/deployments.go
index b4089272d9c..2aebf9a2fe1 100644
--- a/test/e2e/upgrades/apps/deployments.go
+++ b/test/e2e/upgrades/apps/deployments.go
@@ -81,7 +81,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 	By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentStatusValid(c, deployment))
 
-	rs, err := deploymentutil.GetNewReplicaSet(deployment, c)
+	rs, err := deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	framework.ExpectNoError(err)
 	if rs == nil {
 		framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q, found none", deployment.Name))
@@ -108,7 +108,7 @@ func (t *DeploymentUpgradeTest) Setup(f *framework.Framework) {
 	By(fmt.Sprintf("Waiting deployment %q to complete", deploymentName))
 	framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment))
 
-	rs, err = deploymentutil.GetNewReplicaSet(deployment, c)
+	rs, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 	framework.ExpectNoError(err)
 	if rs == nil {
 		framework.ExpectNoError(fmt.Errorf("expected a new replica set for deployment %q", deployment.Name))
@@ -141,7 +141,7 @@ func (t *DeploymentUpgradeTest) Test(f *framework.Framework, done <-chan struct{
 	framework.ExpectNoError(framework.WaitForDeploymentStatus(c, deployment))
 
 	By(fmt.Sprintf("Checking that replica sets for deployment %q are the same as prior to the upgrade", t.updatedD.Name))
-	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(t.updatedD, c)
+	_, allOldRSs, newRS, err := deploymentutil.GetAllReplicaSets(t.updatedD, c.ExtensionsV1beta1())
 	framework.ExpectNoError(err)
 	if newRS == nil {
 		By(t.spewDeploymentAndReplicaSets(newRS, allOldRSs))
diff --git a/test/e2e_federation/ingress.go b/test/e2e_federation/ingress.go
index d0043ca4247..bc77721a22e 100644
--- a/test/e2e_federation/ingress.go
+++ b/test/e2e_federation/ingress.go
@@ -327,7 +327,7 @@ func waitForIngressOrFail(clientset *kubeclientset.Clientset, namespace string,
 	var clusterIngress *v1beta1.Ingress
 	err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
 		var err error
-		clusterIngress, err = clientset.Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
+		clusterIngress, err = clientset.ExtensionsV1beta1().Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
 		if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone.
 			By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is absent", ingress.Name, namespace))
 			return true, nil // Success
@@ -367,7 +367,7 @@ func waitForIngressShardsUpdatedOrFail(namespace string, ingress *v1beta1.Ingres
 func waitForIngressUpdateOrFail(clientset *kubeclientset.Clientset, namespace string, ingress *v1beta1.Ingress, timeout time.Duration) {
 	By(fmt.Sprintf("Fetching a federated ingress shard of ingress %q in namespace %q from cluster", ingress.Name, namespace))
 	err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
-		clusterIngress, err := clientset.Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
+		clusterIngress, err := clientset.ExtensionsV1beta1().Ingresses(namespace).Get(ingress.Name, metav1.GetOptions{})
 		if err == nil { // We want it present, and the Get succeeded, so we're all good.
 			if equivalentIngress(*clusterIngress, *ingress) {
 				By(fmt.Sprintf("Success: shard of federated ingress %q in namespace %q in cluster is updated", ingress.Name, namespace))
@@ -394,7 +394,7 @@ func deleteIngressOrFail(clientset *fedclientset.Clientset, namespace string, in
 	if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 {
 		Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteIngressOrFail: clientset: %v, namespace: %v, ingress: %v", clientset, namespace, ingressName))
 	}
-	err := clientset.Ingresses(namespace).Delete(ingressName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
+	err := clientset.ExtensionsV1beta1().Ingresses(namespace).Delete(ingressName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
 	framework.ExpectNoError(err, "Error deleting ingress %q from namespace %q", ingressName, namespace)
 	// Wait for the ingress to be deleted.
 	err = wait.Poll(framework.Poll, FederatedIngressDeleteTimeout, func() (bool, error) {
@@ -414,7 +414,7 @@ func deleteClusterIngressOrFail(clusterName string, clientset *kubeclientset.Cli
 	if clientset == nil || len(namespace) == 0 || len(ingressName) == 0 {
 		Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteClusterIngressOrFail: cluster: %q, clientset: %v, namespace: %v, ingress: %v", clusterName, clientset, namespace, ingressName))
 	}
-	err := clientset.Ingresses(namespace).Delete(ingressName, metav1.NewDeleteOptions(0))
+	err := clientset.ExtensionsV1beta1().Ingresses(namespace).Delete(ingressName, metav1.NewDeleteOptions(0))
 	framework.ExpectNoError(err, "Error deleting cluster ingress %q/%q from cluster %q", namespace, ingressName, clusterName)
 }
 
diff --git a/test/e2e_federation/replicaset.go b/test/e2e_federation/replicaset.go
index 45bc9802097..6df94ee85e3 100644
--- a/test/e2e_federation/replicaset.go
+++ b/test/e2e_federation/replicaset.go
@@ -311,7 +311,7 @@ func waitForReplicaSetOrFail(c *fedclientset.Clientset, namespace string, replic
 func waitForReplicaSet(c *fedclientset.Clientset, namespace string, replicaSetName string, clusters fedframework.ClusterSlice, expect map[string]int32) error {
 	framework.Logf("waitForReplicaSet: %s/%s; clusters: %v; expect: %v", namespace, replicaSetName, clusters, expect)
 	err := wait.Poll(10*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
-		frs, err := c.ReplicaSets(namespace).Get(replicaSetName, metav1.GetOptions{})
+		frs, err := c.ExtensionsV1beta1().ReplicaSets(namespace).Get(replicaSetName, metav1.GetOptions{})
 		if err != nil {
 			return false, err
 		}
@@ -392,7 +392,7 @@ func updateReplicaSetOrFail(clientset *fedclientset.Clientset, replicaset *v1bet
 	}
 	By(fmt.Sprintf("Updating federation replicaset %q in namespace %q", replicaset.Name, namespace))
 
-	newRS, err := clientset.ReplicaSets(namespace).Update(replicaset)
+	newRS, err := clientset.ExtensionsV1beta1().ReplicaSets(namespace).Update(replicaset)
 	framework.ExpectNoError(err, "Updating replicaset %q in namespace %q", replicaset.Name, namespace)
 	By(fmt.Sprintf("Successfully updated federation replicaset %q in namespace %q", replicaset.Name, namespace))
 
diff --git a/test/e2e_federation/service.go b/test/e2e_federation/service.go
index a7940675c1e..6dda940c687 100644
--- a/test/e2e_federation/service.go
+++ b/test/e2e_federation/service.go
@@ -68,7 +68,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
 			By(fmt.Sprintf("Creation of service %q in namespace %q succeeded.  Deleting service.", service.Name, nsName))
 
 			// Cleanup
-			err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
+			err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
 			framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace)
 			By(fmt.Sprintf("Deletion of service %q in namespace %q succeeded.", service.Name, nsName))
 		})
@@ -113,7 +113,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
 				service = createServiceOrFail(f.FederationClientset, nsName, FederatedServiceName)
 				defer func() { // Cleanup
 					By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName))
-					err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
+					err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
 					framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName)
 				}()
 				By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name))
@@ -151,7 +151,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
 				defer func() {
 					// Cleanup
 					By(fmt.Sprintf("Deleting service %q in namespace %q", service.Name, nsName))
-					err := f.FederationClientset.Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
+					err := f.FederationClientset.CoreV1().Services(nsName).Delete(service.Name, &metav1.DeleteOptions{})
 					framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, nsName)
 				}()
 				By(fmt.Sprintf("Wait for service shards to be created in all clusters for service \"%s/%s\"", nsName, service.Name))
@@ -258,7 +258,7 @@ var _ = framework.KubeDescribe("Federated Services [Feature:Federation]", func()
 				By("Verified that DNS rules are working as expected")
 
 				By("Deleting the service to verify that DNS rules still work")
-				err := f.FederationClientset.Services(nsName).Delete(FederatedServiceName, &metav1.DeleteOptions{})
+				err := f.FederationClientset.CoreV1().Services(nsName).Delete(FederatedServiceName, &metav1.DeleteOptions{})
 				framework.ExpectNoError(err, "Error deleting service %q in namespace %q", service.Name, service.Namespace)
 				// Service is deleted, unset the test block-global service variable.
 				service = nil
@@ -359,16 +359,16 @@ func verifyCascadingDeletionForService(clientset *fedclientset.Clientset, cluste
 }
 
 func updateServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service {
-	service, err := clientset.Services(namespace).Get(name, metav1.GetOptions{})
+	service, err := clientset.CoreV1().Services(namespace).Get(name, metav1.GetOptions{})
 	framework.ExpectNoError(err, "Getting service %q in namespace %q", name, namespace)
 	service.Spec.Selector["name"] = "update-demo"
-	newService, err := clientset.Services(namespace).Update(service)
+	newService, err := clientset.CoreV1().Services(namespace).Update(service)
 	By(fmt.Sprintf("Successfully updated federated service %q in namespace %q", name, namespace))
 	return newService
 }
 
 func deleteServiceShard(c *fedframework.Cluster, namespace, service string) error {
-	err := c.Clientset.Services(namespace).Delete(service, &metav1.DeleteOptions{})
+	err := c.Clientset.CoreV1().Services(namespace).Delete(service, &metav1.DeleteOptions{})
 	if err != nil && !errors.IsNotFound(err) {
 		framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service, namespace, c.Name)
 		return err
diff --git a/test/e2e_federation/util.go b/test/e2e_federation/util.go
index 7e7735d9501..0ddf52c0da5 100644
--- a/test/e2e_federation/util.go
+++ b/test/e2e_federation/util.go
@@ -88,7 +88,7 @@ func createClusterObjectOrFail(f *fedframework.Framework, context *fedframework.
 func waitForServiceOrFail(clientset *kubeclientset.Clientset, namespace string, service *v1.Service, present bool, timeout time.Duration) {
 	By(fmt.Sprintf("Fetching a federated service shard of service %q in namespace %q from cluster", service.Name, namespace))
 	err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
-		clusterService, err := clientset.Services(namespace).Get(service.Name, metav1.GetOptions{})
+		clusterService, err := clientset.CoreV1().Services(namespace).Get(service.Name, metav1.GetOptions{})
 		if (!present) && errors.IsNotFound(err) { // We want it gone, and it's gone.
 			By(fmt.Sprintf("Success: shard of federated service %q in namespace %q in cluster is absent", service.Name, namespace))
 			return true, nil // Success
@@ -141,7 +141,7 @@ func createService(clientset *fedclientset.Clientset, namespace, name string) (*
 	}
 
 	By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace))
-	return clientset.Services(namespace).Create(service)
+	return clientset.CoreV1().Services(namespace).Create(service)
 }
 
 func createLBService(clientset *fedclientset.Clientset, namespace, name string) (*v1.Service, error) {
@@ -178,7 +178,7 @@ func createLBService(clientset *fedclientset.Clientset, namespace, name string)
 	}
 
 	By(fmt.Sprintf("Trying to create service %q in namespace %q", service.Name, namespace))
-	return clientset.Services(namespace).Create(service)
+	return clientset.CoreV1().Services(namespace).Create(service)
 }
 
 func createServiceOrFail(clientset *fedclientset.Clientset, namespace, name string) *v1.Service {
@@ -200,7 +200,7 @@ func deleteServiceOrFail(clientset *fedclientset.Clientset, namespace string, se
 		Fail(fmt.Sprintf("Internal error: invalid parameters passed to deleteServiceOrFail: clientset: %v, namespace: %v, service: %v", clientset, namespace, serviceName))
 	}
 	framework.Logf("Deleting service %q in namespace %v", serviceName, namespace)
-	err := clientset.Services(namespace).Delete(serviceName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
+	err := clientset.CoreV1().Services(namespace).Delete(serviceName, &metav1.DeleteOptions{OrphanDependents: orphanDependents})
 	framework.ExpectNoError(err, "Error deleting service %q from namespace %q", serviceName, namespace)
 	// Wait for the service to be deleted.
 	err = wait.Poll(5*time.Second, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
@@ -224,7 +224,7 @@ func cleanupServiceShardsAndProviderResources(namespace string, service *v1.Serv
 
 		err := wait.PollImmediate(framework.Poll, fedframework.FederatedDefaultTestTimeout, func() (bool, error) {
 			var err error
-			cSvc, err = c.Clientset.Services(namespace).Get(service.Name, metav1.GetOptions{})
+			cSvc, err = c.Clientset.CoreV1().Services(namespace).Get(service.Name, metav1.GetOptions{})
 			if err != nil && !errors.IsNotFound(err) {
 				// Get failed with an error, try again.
 				framework.Logf("Failed to find service %q in namespace %q, in cluster %q: %v. Trying again in %s", service.Name, namespace, name, err, framework.Poll)
@@ -260,7 +260,7 @@ func cleanupServiceShardsAndProviderResources(namespace string, service *v1.Serv
 
 func cleanupServiceShard(clientset *kubeclientset.Clientset, clusterName, namespace string, service *v1.Service, timeout time.Duration) error {
 	err := wait.PollImmediate(framework.Poll, timeout, func() (bool, error) {
-		err := clientset.Services(namespace).Delete(service.Name, &metav1.DeleteOptions{})
+		err := clientset.CoreV1().Services(namespace).Delete(service.Name, &metav1.DeleteOptions{})
 		if err != nil && !errors.IsNotFound(err) {
 			// Deletion failed with an error, try again.
 			framework.Logf("Failed to delete service %q in namespace %q, in cluster %q", service.Name, namespace, clusterName)
diff --git a/test/e2e_node/e2e_node_suite_test.go b/test/e2e_node/e2e_node_suite_test.go
index 9a228bb4fc2..dbef75738fa 100644
--- a/test/e2e_node/e2e_node_suite_test.go
+++ b/test/e2e_node/e2e_node_suite_test.go
@@ -265,7 +265,7 @@ func updateTestContext() error {
 
 // getNode gets node object from the apiserver.
 func getNode(c *clientset.Clientset) (*v1.Node, error) {
-	nodes, err := c.Nodes().List(metav1.ListOptions{})
+	nodes, err := c.CoreV1().Nodes().List(metav1.ListOptions{})
 	Expect(err).NotTo(HaveOccurred(), "should be able to list nodes.")
 	if nodes == nil {
 		return nil, fmt.Errorf("the node list is nil.")
diff --git a/test/integration/deployment/deployment_test.go b/test/integration/deployment/deployment_test.go
index f8489442d32..756c1f9b92f 100644
--- a/test/integration/deployment/deployment_test.go
+++ b/test/integration/deployment/deployment_test.go
@@ -58,7 +58,7 @@ func TestNewDeployment(t *testing.T) {
 	tester.waitForDeploymentStatusValidAndMarkPodsReady()
 
 	// Check new RS annotations
-	newRS, err := deploymentutil.GetNewReplicaSet(deploy, c)
+	newRS, err := deploymentutil.GetNewReplicaSet(deploy, c.ExtensionsV1beta1())
 	if err != nil {
 		t.Fatalf("failed to get new ReplicaSet of Deployment %s: %v", deploy.Name, err)
 	}
diff --git a/test/integration/master/master_test.go b/test/integration/master/master_test.go
index d7378662ef3..dd7f5fd0dc4 100644
--- a/test/integration/master/master_test.go
+++ b/test/integration/master/master_test.go
@@ -99,7 +99,7 @@ func TestKubernetesService(t *testing.T) {
 	_, _, closeFn := framework.RunAMaster(config)
 	defer closeFn()
 	coreClient := clientset.NewForConfigOrDie(config.GenericConfig.LoopbackClientConfig)
-	if _, err := coreClient.Services(metav1.NamespaceDefault).Get("kubernetes", metav1.GetOptions{}); err != nil {
+	if _, err := coreClient.Core().Services(metav1.NamespaceDefault).Get("kubernetes", metav1.GetOptions{}); err != nil {
 		t.Fatalf("Expected kubernetes service to exists, got: %v", err)
 	}
 }
diff --git a/test/integration/volume/persistent_volumes_test.go b/test/integration/volume/persistent_volumes_test.go
index d79ffbe918f..b50efd829a8 100644
--- a/test/integration/volume/persistent_volumes_test.go
+++ b/test/integration/volume/persistent_volumes_test.go
@@ -127,13 +127,13 @@ func TestPersistentVolumeRecycler(t *testing.T) {
 	pv := createPV("fake-pv-recycler", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimRecycle)
 	pvc := createPVC("fake-pvc-recycler", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
 
-	_, err := testClient.PersistentVolumes().Create(pv)
+	_, err := testClient.CoreV1().PersistentVolumes().Create(pv)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolume: %v", err)
 	}
 	glog.V(2).Infof("TestPersistentVolumeRecycler pvc created")
 
-	_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -146,7 +146,7 @@ func TestPersistentVolumeRecycler(t *testing.T) {
 	glog.V(2).Infof("TestPersistentVolumeRecycler pvc bound")
 
 	// deleting a claim releases the volume, after which it can be recycled
-	if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
+	if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
 		t.Errorf("error deleting claim %s", pvc.Name)
 	}
 	glog.V(2).Infof("TestPersistentVolumeRecycler pvc deleted")
@@ -182,12 +182,12 @@ func TestPersistentVolumeDeleter(t *testing.T) {
 	pv := createPV("fake-pv-deleter", "/tmp/foo", "10G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, v1.PersistentVolumeReclaimDelete)
 	pvc := createPVC("fake-pvc-deleter", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
 
-	_, err := testClient.PersistentVolumes().Create(pv)
+	_, err := testClient.CoreV1().PersistentVolumes().Create(pv)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolume: %v", err)
 	}
 	glog.V(2).Infof("TestPersistentVolumeDeleter pv created")
-	_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -198,7 +198,7 @@ func TestPersistentVolumeDeleter(t *testing.T) {
 	glog.V(2).Infof("TestPersistentVolumeDeleter pvc bound")
 
 	// deleting a claim releases the volume, after which it can be recycled
-	if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
+	if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
 		t.Errorf("error deleting claim %s", pvc.Name)
 	}
 	glog.V(2).Infof("TestPersistentVolumeDeleter pvc deleted")
@@ -248,7 +248,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
 		clone, _ := api.Scheme.DeepCopy(pvc)
 		newPvc, _ := clone.(*v1.PersistentVolumeClaim)
 		newPvc.ObjectMeta = metav1.ObjectMeta{Name: fmt.Sprintf("fake-pvc-race-%d", counter)}
-		claim, err := testClient.PersistentVolumeClaims(ns.Name).Create(newPvc)
+		claim, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(newPvc)
 		if err != nil {
 			t.Fatalf("Error creating newPvc: %v", err)
 		}
@@ -266,7 +266,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
 	pv.Spec.ClaimRef = claimRef
 	pv.Spec.ClaimRef.UID = ""
 
-	pv, err = testClient.PersistentVolumes().Create(pv)
+	pv, err = testClient.CoreV1().PersistentVolumes().Create(pv)
 	if err != nil {
 		t.Fatalf("Unexpected error creating pv: %v", err)
 	}
@@ -277,7 +277,7 @@ func TestPersistentVolumeBindRace(t *testing.T) {
 	waitForAnyPersistentVolumeClaimPhase(watchPVC, v1.ClaimBound)
 	glog.V(2).Infof("TestPersistentVolumeBindRace pvc bound")
 
-	pv, err = testClient.PersistentVolumes().Get(pv.Name, metav1.GetOptions{})
+	pv, err = testClient.CoreV1().PersistentVolumes().Get(pv.Name, metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
@@ -323,11 +323,11 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
 	pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "true"})
 	pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "false"})
 
-	_, err = testClient.PersistentVolumes().Create(pv_true)
+	_, err = testClient.CoreV1().PersistentVolumes().Create(pv_true)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolume: %v", err)
 	}
-	_, err = testClient.PersistentVolumes().Create(pv_false)
+	_, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolume: %v", err)
 	}
@@ -339,7 +339,7 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
 		},
 	}
 
-	_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -350,14 +350,14 @@ func TestPersistentVolumeClaimLabelSelector(t *testing.T) {
 	waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound)
 	t.Log("claim bound")
 
-	pv, err := testClient.PersistentVolumes().Get("pv-false", metav1.GetOptions{})
+	pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-false", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
 	if pv.Spec.ClaimRef != nil {
 		t.Fatalf("False PV shouldn't be bound")
 	}
-	pv, err = testClient.PersistentVolumes().Get("pv-true", metav1.GetOptions{})
+	pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-true", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
@@ -404,11 +404,11 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
 	pv_true.ObjectMeta.SetLabels(map[string]string{"foo": "valA", "bar": ""})
 	pv_false.ObjectMeta.SetLabels(map[string]string{"foo": "valB", "baz": ""})
 
-	_, err = testClient.PersistentVolumes().Create(pv_true)
+	_, err = testClient.CoreV1().PersistentVolumes().Create(pv_true)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolume: %v", err)
 	}
-	_, err = testClient.PersistentVolumes().Create(pv_false)
+	_, err = testClient.CoreV1().PersistentVolumes().Create(pv_false)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolume: %v", err)
 	}
@@ -439,7 +439,7 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
 		},
 	}
 
-	_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Fatalf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -450,14 +450,14 @@ func TestPersistentVolumeClaimLabelSelectorMatchExpressions(t *testing.T) {
 	waitForPersistentVolumeClaimPhase(testClient, pvc.Name, ns.Name, watchPVC, v1.ClaimBound)
 	t.Log("claim bound")
 
-	pv, err := testClient.PersistentVolumes().Get("pv-false", metav1.GetOptions{})
+	pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-false", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
 	if pv.Spec.ClaimRef != nil {
 		t.Fatalf("False PV shouldn't be bound")
 	}
-	pv, err = testClient.PersistentVolumes().Get("pv-true", metav1.GetOptions{})
+	pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-true", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
@@ -502,7 +502,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
 	pvc := createPVC("pvc-2", ns.Name, strconv.Itoa(maxPVs/2)+"G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
 
 	for i := 0; i < maxPVs; i++ {
-		_, err := testClient.PersistentVolumes().Create(pvs[i])
+		_, err := testClient.CoreV1().PersistentVolumes().Create(pvs[i])
 		if err != nil {
 			t.Errorf("Failed to create PersistentVolume %d: %v", i, err)
 		}
@@ -510,7 +510,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
 	}
 	t.Log("volumes created")
 
-	_, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -525,7 +525,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
 	// only one PV is bound
 	bound := 0
 	for i := 0; i < maxPVs; i++ {
-		pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
+		pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
 		if err != nil {
 			t.Fatalf("Unexpected error getting pv: %v", err)
 		}
@@ -550,7 +550,7 @@ func TestPersistentVolumeMultiPVs(t *testing.T) {
 	}
 
 	// deleting a claim releases the volume
-	if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
+	if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
 		t.Errorf("error deleting claim %s", pvc.Name)
 	}
 	t.Log("claim deleted")
@@ -599,7 +599,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 	// with >3000 volumes.
 	go func() {
 		for i := 0; i < objCount; i++ {
-			_, _ = testClient.PersistentVolumes().Create(pvs[i])
+			_, _ = testClient.CoreV1().PersistentVolumes().Create(pvs[i])
 		}
 	}()
 	// Wait for them to get Available
@@ -620,7 +620,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 				// Modify PV
 				i := rand.Intn(objCount)
 				name := "pv-" + strconv.Itoa(i)
-				pv, err := testClient.PersistentVolumes().Get(name, metav1.GetOptions{})
+				pv, err := testClient.CoreV1().PersistentVolumes().Get(name, metav1.GetOptions{})
 				if err != nil {
 					// Silently ignore error, the PV may have be already deleted
 					// or not exists yet.
@@ -632,7 +632,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 				} else {
 					pv.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int())
 				}
-				_, err = testClient.PersistentVolumes().Update(pv)
+				_, err = testClient.CoreV1().PersistentVolumes().Update(pv)
 				if err != nil {
 					// Silently ignore error, the PV may have been updated by
 					// the controller.
@@ -644,7 +644,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 				// Modify PVC
 				i := rand.Intn(objCount)
 				name := "pvc-" + strconv.Itoa(i)
-				pvc, err := testClient.PersistentVolumeClaims(metav1.NamespaceDefault).Get(name, metav1.GetOptions{})
+				pvc, err := testClient.CoreV1().PersistentVolumeClaims(metav1.NamespaceDefault).Get(name, metav1.GetOptions{})
 				if err != nil {
 					// Silently ignore error, the PVC may have be already
 					// deleted or not exists yet.
@@ -656,7 +656,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 				} else {
 					pvc.Annotations["TestAnnotation"] = fmt.Sprint(rand.Int())
 				}
-				_, err = testClient.PersistentVolumeClaims(metav1.NamespaceDefault).Update(pvc)
+				_, err = testClient.CoreV1().PersistentVolumeClaims(metav1.NamespaceDefault).Update(pvc)
 				if err != nil {
 					// Silently ignore error, the PVC may have been updated by
 					// the controller.
@@ -679,7 +679,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 	// Create the claims, again in a separate goroutine.
 	go func() {
 		for i := 0; i < objCount; i++ {
-			_, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i])
+			_, _ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvcs[i])
 		}
 	}()
 
@@ -699,7 +699,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 
 	// check that everything is bound to something
 	for i := 0; i < objCount; i++ {
-		pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
+		pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
 		if err != nil {
 			t.Fatalf("Unexpected error getting pv: %v", err)
 		}
@@ -708,7 +708,7 @@ func TestPersistentVolumeMultiPVsPVCs(t *testing.T) {
 		}
 		glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name)
 
-		pvc, err := testClient.PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
+		pvc, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
 		if err != nil {
 			t.Fatalf("Unexpected error getting pvc: %v", err)
 		}
@@ -748,13 +748,13 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
 		pvc := createPVC(pvcName, ns.Name, "1G", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}, "")
 		pvc.Annotations = map[string]string{"annBindCompleted": ""}
 		pvc.Spec.VolumeName = pvName
-		newPVC, err := testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+		newPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 		if err != nil {
 			t.Fatalf("Cannot create claim %q: %v", pvc.Name, err)
 		}
 		// Save Bound status as a separate transaction
 		newPVC.Status.Phase = v1.ClaimBound
-		newPVC, err = testClient.PersistentVolumeClaims(ns.Name).UpdateStatus(newPVC)
+		newPVC, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).UpdateStatus(newPVC)
 		if err != nil {
 			t.Fatalf("Cannot update claim status %q: %v", pvc.Name, err)
 		}
@@ -772,13 +772,13 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
 			return
 		}
 		pv.Spec.ClaimRef = claimRef
-		newPV, err := testClient.PersistentVolumes().Create(pv)
+		newPV, err := testClient.CoreV1().PersistentVolumes().Create(pv)
 		if err != nil {
 			t.Fatalf("Cannot create volume %q: %v", pv.Name, err)
 		}
 		// Save Bound status as a separate transaction
 		newPV.Status.Phase = v1.VolumeBound
-		newPV, err = testClient.PersistentVolumes().UpdateStatus(newPV)
+		newPV, err = testClient.CoreV1().PersistentVolumes().UpdateStatus(newPV)
 		if err != nil {
 			t.Fatalf("Cannot update volume status %q: %v", pv.Name, err)
 		}
@@ -829,7 +829,7 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
 
 	// check that everything is bound to something
 	for i := 0; i < objCount; i++ {
-		pv, err := testClient.PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
+		pv, err := testClient.CoreV1().PersistentVolumes().Get(pvs[i].Name, metav1.GetOptions{})
 		if err != nil {
 			t.Fatalf("Unexpected error getting pv: %v", err)
 		}
@@ -838,7 +838,7 @@ func TestPersistentVolumeControllerStartup(t *testing.T) {
 		}
 		glog.V(2).Infof("PV %q is bound to PVC %q", pv.Name, pv.Spec.ClaimRef.Name)
 
-		pvc, err := testClient.PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
+		pvc, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Get(pvcs[i].Name, metav1.GetOptions{})
 		if err != nil {
 			t.Fatalf("Unexpected error getting pvc: %v", err)
 		}
@@ -895,7 +895,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
 	// early. It gets stuck with >3000 claims.
 	go func() {
 		for i := 0; i < objCount; i++ {
-			_, _ = testClient.PersistentVolumeClaims(ns.Name).Create(pvcs[i])
+			_, _ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvcs[i])
 		}
 	}()
 
@@ -907,7 +907,7 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
 	glog.V(2).Infof("TestPersistentVolumeProvisionMultiPVCs: claims are bound")
 
 	// check that we have enough bound PVs
-	pvList, err := testClient.PersistentVolumes().List(metav1.ListOptions{})
+	pvList, err := testClient.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
 	if err != nil {
 		t.Fatalf("Failed to list volumes: %s", err)
 	}
@@ -924,13 +924,13 @@ func TestPersistentVolumeProvisionMultiPVCs(t *testing.T) {
 
 	// Delete the claims
 	for i := 0; i < objCount; i++ {
-		_ = testClient.PersistentVolumeClaims(ns.Name).Delete(pvcs[i].Name, nil)
+		_ = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvcs[i].Name, nil)
 	}
 
 	// Wait for the PVs to get deleted by listing remaining volumes
 	// (delete events were unreliable)
 	for {
-		volumes, err := testClient.PersistentVolumes().List(metav1.ListOptions{})
+		volumes, err := testClient.CoreV1().PersistentVolumes().List(metav1.ListOptions{})
 		if err != nil {
 			t.Fatalf("Failed to list volumes: %v", err)
 		}
@@ -974,17 +974,17 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
 
 	pvc := createPVC("pvc-rwm", ns.Name, "5G", []v1.PersistentVolumeAccessMode{v1.ReadWriteMany}, "")
 
-	_, err := testClient.PersistentVolumes().Create(pv_rwm)
+	_, err := testClient.CoreV1().PersistentVolumes().Create(pv_rwm)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolume: %v", err)
 	}
-	_, err = testClient.PersistentVolumes().Create(pv_rwo)
+	_, err = testClient.CoreV1().PersistentVolumes().Create(pv_rwo)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolume: %v", err)
 	}
 	t.Log("volumes created")
 
-	_, err = testClient.PersistentVolumeClaims(ns.Name).Create(pvc)
+	_, err = testClient.CoreV1().PersistentVolumeClaims(ns.Name).Create(pvc)
 	if err != nil {
 		t.Errorf("Failed to create PersistentVolumeClaim: %v", err)
 	}
@@ -997,14 +997,14 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
 	t.Log("claim bound")
 
 	// only RWM PV is bound
-	pv, err := testClient.PersistentVolumes().Get("pv-rwo", metav1.GetOptions{})
+	pv, err := testClient.CoreV1().PersistentVolumes().Get("pv-rwo", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
 	if pv.Spec.ClaimRef != nil {
 		t.Fatalf("ReadWriteOnce PV shouldn't be bound")
 	}
-	pv, err = testClient.PersistentVolumes().Get("pv-rwm", metav1.GetOptions{})
+	pv, err = testClient.CoreV1().PersistentVolumes().Get("pv-rwm", metav1.GetOptions{})
 	if err != nil {
 		t.Fatalf("Unexpected error getting pv: %v", err)
 	}
@@ -1016,7 +1016,7 @@ func TestPersistentVolumeMultiPVsDiffAccessModes(t *testing.T) {
 	}
 
 	// deleting a claim releases the volume
-	if err := testClient.PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
+	if err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Delete(pvc.Name, nil); err != nil {
 		t.Errorf("error deleting claim %s", pvc.Name)
 	}
 	t.Log("claim deleted")
@@ -1142,11 +1142,11 @@ func createClients(ns *v1.Namespace, t *testing.T, s *httptest.Server, syncPerio
 		t.Fatalf("Failed to construct PersistentVolumes: %v", err)
 	}
 
-	watchPV, err := testClient.PersistentVolumes().Watch(metav1.ListOptions{})
+	watchPV, err := testClient.CoreV1().PersistentVolumes().Watch(metav1.ListOptions{})
 	if err != nil {
 		t.Fatalf("Failed to watch PersistentVolumes: %v", err)
 	}
-	watchPVC, err := testClient.PersistentVolumeClaims(ns.Name).Watch(metav1.ListOptions{})
+	watchPVC, err := testClient.CoreV1().PersistentVolumeClaims(ns.Name).Watch(metav1.ListOptions{})
 	if err != nil {
 		t.Fatalf("Failed to watch PersistentVolumeClaims: %v", err)
 	}
diff --git a/test/soak/serve_hostnames/serve_hostnames.go b/test/soak/serve_hostnames/serve_hostnames.go
index 88653c2d592..62883b71d43 100644
--- a/test/soak/serve_hostnames/serve_hostnames.go
+++ b/test/soak/serve_hostnames/serve_hostnames.go
@@ -92,7 +92,7 @@ func main() {
 
 	var nodes *v1.NodeList
 	for start := time.Now(); time.Since(start) < nodeListTimeout; time.Sleep(2 * time.Second) {
-		nodes, err = client.Nodes().List(metav1.ListOptions{})
+		nodes, err = client.CoreV1().Nodes().List(metav1.ListOptions{})
 		if err == nil {
 			break
 		}
@@ -114,7 +114,7 @@ func main() {
 	queries := *queriesAverage * len(nodes.Items) * *podsPerNode
 
 	// Create the namespace
-	got, err := client.Namespaces().Create(&v1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "serve-hostnames-"}})
+	got, err := client.CoreV1().Namespaces().Create(&v1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "serve-hostnames-"}})
 	if err != nil {
 		glog.Fatalf("Failed to create namespace: %v", err)
 	}
@@ -125,7 +125,7 @@ func main() {
 		} else {
 			// wait until the namespace disappears
 			for i := 0; i < int(namespaceDeleteTimeout/time.Second); i++ {
-				if _, err := client.Namespaces().Get(ns, metav1.GetOptions{}); err != nil {
+				if _, err := client.CoreV1().Namespaces().Get(ns, metav1.GetOptions{}); err != nil {
 					if errors.IsNotFound(err) {
 						return
 					}
@@ -142,7 +142,7 @@ func main() {
 	var svc *v1.Service
 	for start := time.Now(); time.Since(start) < serviceCreateTimeout; time.Sleep(2 * time.Second) {
 		t := time.Now()
-		svc, err = client.Services(ns).Create(&v1.Service{
+		svc, err = client.CoreV1().Services(ns).Create(&v1.Service{
 			ObjectMeta: metav1.ObjectMeta{
 				Name: "serve-hostnames",
 				Labels: map[string]string{
@@ -175,7 +175,7 @@ func main() {
 		glog.Infof("Cleaning up service %s/serve-hostnames", ns)
 		// Make several attempts to delete the service.
 		for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) {
-			if err := client.Services(ns).Delete(svc.Name, nil); err == nil {
+			if err := client.CoreV1().Services(ns).Delete(svc.Name, nil); err == nil {
 				return
 			}
 			glog.Warningf("After %v unable to delete service %s/%s: %v", time.Since(start), ns, svc.Name, err)
@@ -192,7 +192,7 @@ func main() {
 			for start := time.Now(); time.Since(start) < podCreateTimeout; time.Sleep(2 * time.Second) {
 				glog.Infof("Creating pod %s/%s on node %s", ns, podName, node.Name)
 				t := time.Now()
-				_, err = client.Pods(ns).Create(&v1.Pod{
+				_, err = client.CoreV1().Pods(ns).Create(&v1.Pod{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: podName,
 						Labels: map[string]string{
@@ -228,7 +228,7 @@ func main() {
 		// Make several attempts to delete the pods.
 		for _, podName := range podNames {
 			for start := time.Now(); time.Since(start) < deleteTimeout; time.Sleep(1 * time.Second) {
-				if err = client.Pods(ns).Delete(podName, nil); err == nil {
+				if err = client.CoreV1().Pods(ns).Delete(podName, nil); err == nil {
 					break
 				}
 				glog.Warningf("After %v failed to delete pod %s/%s: %v", time.Since(start), ns, podName, err)
@@ -240,7 +240,7 @@ func main() {
 	for _, podName := range podNames {
 		var pod *v1.Pod
 		for start := time.Now(); time.Since(start) < podStartTimeout; time.Sleep(5 * time.Second) {
-			pod, err = client.Pods(ns).Get(podName, metav1.GetOptions{})
+			pod, err = client.CoreV1().Pods(ns).Get(podName, metav1.GetOptions{})
 			if err != nil {
 				glog.Warningf("Get pod %s/%s failed, ignoring for %v: %v", ns, podName, err, podStartTimeout)
 				continue
diff --git a/test/utils/deployment.go b/test/utils/deployment.go
index dfb77e288e1..464ccebd200 100644
--- a/test/utils/deployment.go
+++ b/test/utils/deployment.go
@@ -85,7 +85,7 @@ func WaitForDeploymentStatusValid(c clientset.Interface, d *extensions.Deploymen
 		if err != nil {
 			return false, err
 		}
-		oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c)
+		oldRSs, allOldRSs, newRS, err = deploymentutil.GetAllReplicaSets(deployment, c.ExtensionsV1beta1())
 		if err != nil {
 			return false, err
 		}
@@ -154,7 +154,7 @@ func WaitForDeploymentRevisionAndImage(c clientset.Interface, ns, deploymentName
 		}
 		// The new ReplicaSet needs to be non-nil and contain the pod-template-hash label
 
-		newRS, err = deploymentutil.GetNewReplicaSet(deployment, c)
+		newRS, err = deploymentutil.GetNewReplicaSet(deployment, c.ExtensionsV1beta1())
 
 		if err != nil {
 			return false, err