Fix Godeps.json to point to kubernetes-1.11.0-beta.1 tags

Merge remote-tracking branch 'origin/master' into release-1.11
Kubernetes-commit: 4e3b2843df571c3b80c834d7c23bc6da1a22aab8
2026-06-30 22:16:14 +00:00 · 2018-06-08 15:32:32 +00:00 · 2018-05-31 14:24:28 -04:00 · 2018-06-08 15:31:01 +00:00 · 2018-06-08 15:31:00 +00:00 · 2018-06-08 15:30:59 +00:00
891 changed files with 4645 additions and 275779 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,2 +1,3 @@
-Sorry, we do not accept changes directly against this repository. Please see 
-CONTRIBUTING.md for information on where and how to contribute instead.
+Sorry, we do not accept changes directly against this repository, unless the
+change is to the `README.md` itself. Please see 
+`CONTRIBUTING.md` for information on where and how to contribute instead.
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,6 +1,6 @@
 {
 	"ImportPath": "k8s.io/client-go",
-	"GoVersion": "go1.9",
+	"GoVersion": "go1.10",
 	"GodepVersion": "v80",
 	"Packages": [
 		"./..."
@@ -86,6 +86,10 @@
 			"ImportPath": "github.com/golang/protobuf/ptypes/timestamp",
 			"Rev": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9"
 		},
+		{
+			"ImportPath": "github.com/google/btree",
+			"Rev": "7d79101e329e5a3adf994758c578dab82b90c017"
+		},
 		{
 			"ImportPath": "github.com/google/gofuzz",
 			"Rev": "44d81051d367757e1c7c6a5a86423ece9afcf63c"
@@ -104,31 +108,39 @@
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/openstack",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tenants",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v2/tokens",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/openstack/identity/v3/tokens",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/openstack/utils",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
 		},
 		{
 			"ImportPath": "github.com/gophercloud/gophercloud/pagination",
-			"Rev": "6da026c32e2d622cc242d32984259c77237aefe1"
+			"Rev": "781450b3c4fcb4f5182bcc5133adb4b2e4a09d1d"
+		},
+		{
+			"ImportPath": "github.com/gregjones/httpcache",
+			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
+		},
+		{
+			"ImportPath": "github.com/gregjones/httpcache/diskcache",
+			"Rev": "787624de3eb7bd915c329cba748687a3b22666a6"
 		},
 		{
 			"ImportPath": "github.com/hashicorp/golang-lru",
@@ -154,6 +166,10 @@
 			"ImportPath": "github.com/modern-go/reflect2",
 			"Rev": "05fbef0ca5da472bbf96c9322b84a53edc03c9fd"
 		},
+		{
+			"ImportPath": "github.com/peterbourgon/diskv",
+			"Rev": "5f041e8faa004a95c88a202771f4cc3e991971e6"
+		},
 		{
 			"ImportPath": "github.com/pmezard/go-difflib/difflib",
 			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
@@ -252,335 +268,327 @@
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/admissionregistration/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/apps/v1beta2",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/authentication/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/authorization/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/autoscaling/v2beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/batch/v2alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/certificates/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/core/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/events/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/extensions/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/imagepolicy/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/networking/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/policy/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/rbac/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/scheduling/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
+		},
+		{
+			"ImportPath": "k8s.io/api/scheduling/v1beta1",
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/settings/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1alpha1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/api/storage/v1beta1",
-			"Rev": "b7d77fa220f5130ec63c2ca7167dd9653449c64d"
+			"Rev": "c71adde6150917c4e19dfef555f427d5e085f05d"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/equality",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/errors",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/meta",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/resource",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/fuzzer",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/api/testing/roundtrip",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/announced",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
-		},
-		{
-			"ImportPath": "k8s.io/apimachinery/pkg/apimachinery/registered",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/fuzzer",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/internalversion",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1beta1",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/fields",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/labels",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/selection",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/types",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/cache",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/clock",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/diff",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/errors",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/framer",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/httpstream/spdy",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/json",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/net",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/remotecommand",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/sets",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/wait",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/version",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/pkg/watch",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/netutil",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
-			"Rev": "b54e2be8c5c22805a615d4e84c3cbffcdca8654f"
+			"Rev": "40bc35ef007c446a3ed3d1a2d51ed2d9f30f55f4"
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi/pkg/util/proto",
-			"Rev": "50ae88d24ede7b8bad68e23c805b5d3da5c8abaf"
+			"Rev": "86e28c192d2743f0232b9bc5f0a531568ef9f2a5"
 		}
 	]
 }
--- a/40
+++ b/40
@@ -1,45 +1,15 @@
 approvers:
 - caesarxuchao
 - deads2k
- krousey
 - lavalamp
+- liggitt
 - smarterclayton
 - sttts
- liggitt
 reviewers:
- thockin
- lavalamp
- smarterclayton
- wojtek-t
- deads2k
- yujuhong
- derekwaynecarr
 - caesarxuchao
- vishh
- mikedanese
+- deads2k
+- lavalamp
 - liggitt
- nikhiljindal
- gmarek
- erictune
- davidopp
- pmorie
- sttts
- dchen1107
- saad-ali
- zmerlynn
- luxas
- janetkuo
- justinsb
- roberthbailey
- ncdc
- tallclair
- yifan-gu
- eparis
- mwielgus
- timothysc
- feiskyer
- jlowdermilk
 - soltysh
- piosz
- jsafrane
- awly
+- sttts
+- yliaog
--- a/deprecated-dynamic/bad_debt.go
+++ b/deprecated-dynamic/bad_debt.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-package dynamic
+package deprecated_dynamic

 import (
 	"encoding/json"
--- a/deprecated-dynamic/client.go
+++ b/deprecated-dynamic/client.go
@@ -17,7 +17,7 @@ limitations under the License.
 // Package dynamic provides a client interface to arbitrary Kubernetes
 // APIs that exposes common high level operations and exposes common
 // metadata.
-package dynamic
+package deprecated_dynamic

 import (
 	"strings"
@@ -28,6 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/dynamic"
 	restclient "k8s.io/client-go/rest"
 )

@@ -65,13 +66,13 @@ type ResourceInterface interface {
 // and manipulate metadata of a Kubernetes API group, and implements Interface.
 type Client struct {
 	version  schema.GroupVersion
-	delegate DynamicInterface
+	delegate dynamic.Interface
 }

 // NewClient returns a new client based on the passed in config. The
 // codec is ignored, as the dynamic client uses it's own codec.
 func NewClient(conf *restclient.Config, version schema.GroupVersion) (*Client, error) {
-	delegate, err := NewForConfig(conf)
+	delegate, err := dynamic.NewForConfig(conf)
 	if err != nil {
 		return nil, err
 	}
@@ -84,30 +85,47 @@ func NewClient(conf *restclient.Config, version schema.GroupVersion) (*Client, e
 // is ignored. The ResourceInterface inherits the parameter codec of c.
 func (c *Client) Resource(resource *metav1.APIResource, namespace string) ResourceInterface {
 	resourceTokens := strings.SplitN(resource.Name, "/", 2)
-	subresource := ""
+	subresources := []string{}
 	if len(resourceTokens) > 1 {
-		subresource = resourceTokens[1]
+		subresources = strings.Split(resourceTokens[1], "/")
 	}

 	if len(namespace) == 0 {
-		return oldResourceShim(c.delegate.ClusterSubresource(c.version.WithResource(resourceTokens[0]), subresource))
+		return oldResourceShim(c.delegate.Resource(c.version.WithResource(resourceTokens[0])), subresources)
 	}
-	return oldResourceShim(c.delegate.NamespacedSubresource(c.version.WithResource(resourceTokens[0]), subresource, namespace))
+	return oldResourceShim(c.delegate.Resource(c.version.WithResource(resourceTokens[0])).Namespace(namespace), subresources)
 }

 // the old interfaces used the wrong type for lists.  this fixes that
-func oldResourceShim(in DynamicResourceInterface) ResourceInterface {
-	return oldResourceShimType{DynamicResourceInterface: in}
+func oldResourceShim(in dynamic.ResourceInterface, subresources []string) ResourceInterface {
+	return oldResourceShimType{ResourceInterface: in, subresources: subresources}
 }

 type oldResourceShimType struct {
-	DynamicResourceInterface
+	dynamic.ResourceInterface
+	subresources []string
+}
+
+func (s oldResourceShimType) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Create(obj, s.subresources...)
+}
+
+func (s oldResourceShimType) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Update(obj, s.subresources...)
+}
+
+func (s oldResourceShimType) Delete(name string, opts *metav1.DeleteOptions) error {
+	return s.ResourceInterface.Delete(name, opts, s.subresources...)
+}
+
+func (s oldResourceShimType) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
+	return s.ResourceInterface.Get(name, opts, s.subresources...)
 }

 func (s oldResourceShimType) List(opts metav1.ListOptions) (runtime.Object, error) {
-	return s.DynamicResourceInterface.List(opts)
+	return s.ResourceInterface.List(opts)
 }

 func (s oldResourceShimType) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
-	return s.DynamicResourceInterface.Patch(name, pt, data)
+	return s.ResourceInterface.Patch(name, pt, data, s.subresources...)
 }
--- a/deprecated-dynamic/client_pool.go
+++ b/deprecated-dynamic/client_pool.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-package dynamic
+package deprecated_dynamic

 import (
 	"sync"
--- a/deprecated-dynamic/client_test.go
+++ b/deprecated-dynamic/client_test.go
@@ -0,0 +1,623 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package deprecated_dynamic
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/runtime/serializer/streaming"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+	restclient "k8s.io/client-go/rest"
+	restclientwatch "k8s.io/client-go/rest/watch"
+)
+
+func getJSON(version, kind, name string) []byte {
+	return []byte(fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "metadata": {"name": %q}}`, version, kind, name))
+}
+
+func getListJSON(version, kind string, items ...[]byte) []byte {
+	json := fmt.Sprintf(`{"apiVersion": %q, "kind": %q, "items": [%s]}`,
+		version, kind, bytes.Join(items, []byte(",")))
+	return []byte(json)
+}
+
+func getObject(version, kind, name string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": version,
+			"kind":       kind,
+			"metadata": map[string]interface{}{
+				"name": name,
+			},
+		},
+	}
+}
+
+func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
+	srv := httptest.NewServer(http.HandlerFunc(h))
+	cl, err := NewClient(&restclient.Config{
+		Host:          srv.URL,
+		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
+	}, *gv)
+	if err != nil {
+		srv.Close()
+		return nil, nil, err
+	}
+	return cl, srv, nil
+}
+
+func TestList(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		path      string
+		resp      []byte
+		want      *unstructured.UnstructuredList
+	}{
+		{
+			name: "normal_list",
+			path: "/apis/gtest/vtest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+		{
+			name:      "namespaced_list",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			resp: getListJSON("vTest", "rTestList",
+				getJSON("vTest", "rTest", "item1"),
+				getJSON("vTest", "rTest", "item2")),
+			want: &unstructured.UnstructuredList{
+				Object: map[string]interface{}{
+					"apiVersion": "vTest",
+					"kind":       "rTestList",
+				},
+				Items: []unstructured.Unstructured{
+					*getObject("vTest", "rTest", "item1"),
+					*getObject("vTest", "rTest", "item2"),
+				},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("List(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("List(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestGet(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		namespace string
+		name      string
+		path      string
+		resp      []byte
+		want      *unstructured.Unstructured
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_get",
+			path:     "/apis/gtest/vtest/rtest/normal_get",
+			resp:     getJSON("vTest", "rTest", "normal_get"),
+			want:     getObject("vTest", "rTest", "normal_get"),
+		},
+		{
+			resource:  "rtest",
+			namespace: "nstest",
+			name:      "namespaced_get",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_get",
+			resp:      getJSON("vTest", "rTest", "namespaced_get"),
+			want:      getObject("vTest", "rTest", "namespaced_get"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_get",
+			path:     "/apis/gtest/vtest/rtest/normal_subresource_get/srtest",
+			resp:     getJSON("vTest", "srTest", "normal_subresource_get"),
+			want:     getObject("vTest", "srTest", "normal_subresource_get"),
+		},
+		{
+			resource:  "rtest/srtest",
+			namespace: "nstest",
+			name:      "namespaced_subresource_get",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
+			resp:      getJSON("vTest", "srTest", "namespaced_subresource_get"),
+			want:      getObject("vTest", "srTest", "namespaced_subresource_get"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Get(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			w.Write(tc.resp)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Get(tc.name, metav1.GetOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Get(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
+
+func TestDelete(t *testing.T) {
+	background := metav1.DeletePropagationBackground
+	uid := types.UID("uid")
+
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace     string
+		name          string
+		path          string
+		deleteOptions *metav1.DeleteOptions
+	}{
+		{
+			name: "normal_delete",
+			path: "/apis/gtest/vtest/rtest/normal_delete",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
+		},
+		{
+			namespace:     "nstest",
+			name:          "namespaced_delete_with_options",
+			path:          "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete_with_options",
+			deleteOptions: &metav1.DeleteOptions{Preconditions: &metav1.Preconditions{UID: &uid}, PropagationPolicy: &background},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Delete(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).Delete(tc.name, tc.deleteOptions)
+		if err != nil {
+			t.Errorf("unexpected error when deleting %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestDeleteCollection(t *testing.T) {
+	statusOK := &metav1.Status{
+		TypeMeta: metav1.TypeMeta{Kind: "Status"},
+		Status:   metav1.StatusSuccess,
+	}
+	tcs := []struct {
+		namespace string
+		name      string
+		path      string
+	}{
+		{
+			name: "normal_delete_collection",
+			path: "/apis/gtest/vtest/rtest",
+		},
+		{
+			namespace: "nstest",
+			name:      "namespaced_delete_collection",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "DELETE" {
+				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("DeleteCollection(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
+			continue
+		}
+	}
+}
+
+func TestCreate(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_create",
+			path:     "/apis/gtest/vtest/rtest",
+			obj:      getObject("gtest/vTest", "rTest", "normal_create"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_create",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			obj:       getObject("gtest/vTest", "rTest", "namespaced_create"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "POST" {
+				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Create(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Create(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Create(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when creating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Create(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestUpdate(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		obj       *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_update",
+			path:     "/apis/gtest/vtest/rtest/normal_update",
+			obj:      getObject("gtest/vTest", "rTest", "normal_update"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_update",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update",
+			obj:       getObject("gtest/vTest", "rTest", "namespaced_update"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_update",
+			path:     "/apis/gtest/vtest/rtest/normal_update/srtest",
+			obj:      getObject("gtest/vTest", "srTest", "normal_update"),
+		},
+		{
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_update",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
+			obj:       getObject("gtest/vTest", "srTest", "namespaced_update"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PUT" {
+				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Update(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Update(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Update(tc.obj)
+		if err != nil {
+			t.Errorf("unexpected error when updating %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.obj) {
+			t.Errorf("Update(%q) want: %v\ngot: %v", tc.name, tc.obj, got)
+		}
+	}
+}
+
+func TestWatch(t *testing.T) {
+	tcs := []struct {
+		name      string
+		namespace string
+		events    []watch.Event
+		path      string
+		query     string
+	}{
+		{
+			name:  "normal_watch",
+			path:  "/apis/gtest/vtest/rtest",
+			query: "watch=true",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "normal_watch")},
+			},
+		},
+		{
+			name:      "namespaced_watch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
+			query:     "watch=true",
+			events: []watch.Event{
+				{Type: watch.Added, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Modified, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+				{Type: watch.Deleted, Object: getObject("gtest/vTest", "rTest", "namespaced_watch")},
+			},
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "GET" {
+				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+			if r.URL.RawQuery != tc.query {
+				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
+			}
+
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			for _, e := range tc.events {
+				enc.Encode(&e)
+			}
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
+		if err != nil {
+			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
+			continue
+		}
+
+		for _, want := range tc.events {
+			got := <-watcher.ResultChan()
+			if !reflect.DeepEqual(got, want) {
+				t.Errorf("Watch(%q) want: %v\ngot: %v", tc.name, want, got)
+			}
+		}
+	}
+}
+
+func TestPatch(t *testing.T) {
+	tcs := []struct {
+		resource  string
+		name      string
+		namespace string
+		patch     []byte
+		want      *unstructured.Unstructured
+		path      string
+	}{
+		{
+			resource: "rtest",
+			name:     "normal_patch",
+			path:     "/apis/gtest/vtest/rtest/normal_patch",
+			patch:    getJSON("gtest/vTest", "rTest", "normal_patch"),
+			want:     getObject("gtest/vTest", "rTest", "normal_patch"),
+		},
+		{
+			resource:  "rtest",
+			name:      "namespaced_patch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_patch",
+			patch:     getJSON("gtest/vTest", "rTest", "namespaced_patch"),
+			want:      getObject("gtest/vTest", "rTest", "namespaced_patch"),
+		},
+		{
+			resource: "rtest/srtest",
+			name:     "normal_subresource_patch",
+			path:     "/apis/gtest/vtest/rtest/normal_subresource_patch/srtest",
+			patch:    getJSON("gtest/vTest", "srTest", "normal_subresource_patch"),
+			want:     getObject("gtest/vTest", "srTest", "normal_subresource_patch"),
+		},
+		{
+			resource:  "rtest/srtest",
+			name:      "namespaced_subresource_patch",
+			namespace: "nstest",
+			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
+			patch:     getJSON("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+			want:      getObject("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+		},
+	}
+	for _, tc := range tcs {
+		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
+		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+			if r.Method != "PATCH" {
+				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
+			}
+
+			if r.URL.Path != tc.path {
+				t.Errorf("Patch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
+			}
+
+			content := r.Header.Get("Content-Type")
+			if content != string(types.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, types.StrategicMergePatchType)
+			}
+
+			data, err := ioutil.ReadAll(r.Body)
+			if err != nil {
+				t.Errorf("Patch(%q) unexpected error reading body: %v", tc.name, err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+
+			w.Header().Set("Content-Type", "application/json")
+			w.Write(data)
+		})
+		if err != nil {
+			t.Errorf("unexpected error when creating client: %v", err)
+			continue
+		}
+		defer srv.Close()
+
+		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
+		if err != nil {
+			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
+			continue
+		}
+
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("Patch(%q) want: %v\ngot: %v", tc.name, tc.want, got)
+		}
+	}
+}
--- a/discovery/cached/memcache.go
+++ b/discovery/cached/memcache.go
@@ -96,18 +96,12 @@ func (d *memCacheClient) RESTClient() restclient.Interface {
 	return d.delegate.RESTClient()
 }

-// TODO: Should this also be cached? The results seem more likely to be
-// inconsistent with ServerGroups and ServerResources given the requirement to
-// actively Invalidate.
 func (d *memCacheClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	return d.delegate.ServerPreferredResources()
+	return discovery.ServerPreferredResources(d)
 }

-// TODO: Should this also be cached? The results seem more likely to be
-// inconsistent with ServerGroups and ServerResources given the requirement to
-// actively Invalidate.
 func (d *memCacheClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return d.delegate.ServerPreferredNamespacedResources()
+	return discovery.ServerPreferredNamespacedResources(d)
 }

 func (d *memCacheClient) ServerVersion() (*version.Info, error) {
--- a/discovery/cached_discovery.go
+++ b/discovery/cached_discovery.go
@@ -0,0 +1,282 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package discovery
+
+import (
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+	"github.com/googleapis/gnostic/OpenAPIv2"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/version"
+	"k8s.io/client-go/kubernetes/scheme"
+	restclient "k8s.io/client-go/rest"
+)
+
+// CachedDiscoveryClient implements the functions that discovery server-supported API groups,
+// versions and resources.
+type CachedDiscoveryClient struct {
+	delegate DiscoveryInterface
+
+	// cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
+	cacheDirectory string
+
+	// ttl is how long the cache should be considered valid
+	ttl time.Duration
+
+	// mutex protects the variables below
+	mutex sync.Mutex
+
+	// ourFiles are all filenames of cache files created by this process
+	ourFiles map[string]struct{}
+	// invalidated is true if all cache files should be ignored that are not ours (e.g. after Invalidate() was called)
+	invalidated bool
+	// fresh is true if all used cache files were ours
+	fresh bool
+}
+
+var _ CachedDiscoveryInterface = &CachedDiscoveryClient{}
+
+// ServerResourcesForGroupVersion returns the supported resources for a group and version.
+func (d *CachedDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	filename := filepath.Join(d.cacheDirectory, groupVersion, "serverresources.json")
+	cachedBytes, err := d.getCachedFile(filename)
+	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
+	if err == nil {
+		cachedResources := &metav1.APIResourceList{}
+		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedResources); err == nil {
+			glog.V(10).Infof("returning cached discovery info from %v", filename)
+			return cachedResources, nil
+		}
+	}
+
+	liveResources, err := d.delegate.ServerResourcesForGroupVersion(groupVersion)
+	if err != nil {
+		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		return liveResources, err
+	}
+	if liveResources == nil || len(liveResources.APIResources) == 0 {
+		glog.V(3).Infof("skipped caching discovery info, no resources found")
+		return liveResources, err
+	}
+
+	if err := d.writeCachedFile(filename, liveResources); err != nil {
+		glog.V(3).Infof("failed to write cache to %v due to %v", filename, err)
+	}
+
+	return liveResources, nil
+}
+
+// ServerResources returns the supported resources for all groups and versions.
+func (d *CachedDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	return ServerResources(d)
+}
+
+func (d *CachedDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
+	filename := filepath.Join(d.cacheDirectory, "servergroups.json")
+	cachedBytes, err := d.getCachedFile(filename)
+	// don't fail on errors, we either don't have a file or won't be able to run the cached check. Either way we can fallback.
+	if err == nil {
+		cachedGroups := &metav1.APIGroupList{}
+		if err := runtime.DecodeInto(scheme.Codecs.UniversalDecoder(), cachedBytes, cachedGroups); err == nil {
+			glog.V(10).Infof("returning cached discovery info from %v", filename)
+			return cachedGroups, nil
+		}
+	}
+
+	liveGroups, err := d.delegate.ServerGroups()
+	if err != nil {
+		glog.V(3).Infof("skipped caching discovery info due to %v", err)
+		return liveGroups, err
+	}
+	if liveGroups == nil || len(liveGroups.Groups) == 0 {
+		glog.V(3).Infof("skipped caching discovery info, no groups found")
+		return liveGroups, err
+	}
+
+	if err := d.writeCachedFile(filename, liveGroups); err != nil {
+		glog.V(3).Infof("failed to write cache to %v due to %v", filename, err)
+	}
+
+	return liveGroups, nil
+}
+
+func (d *CachedDiscoveryClient) getCachedFile(filename string) ([]byte, error) {
+	// after invalidation ignore cache files not created by this process
+	d.mutex.Lock()
+	_, ourFile := d.ourFiles[filename]
+	if d.invalidated && !ourFile {
+		d.mutex.Unlock()
+		return nil, errors.New("cache invalidated")
+	}
+	d.mutex.Unlock()
+
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	if time.Now().After(fileInfo.ModTime().Add(d.ttl)) {
+		return nil, errors.New("cache expired")
+	}
+
+	// the cache is present and its valid.  Try to read and use it.
+	cachedBytes, err := ioutil.ReadAll(file)
+	if err != nil {
+		return nil, err
+	}
+
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+	d.fresh = d.fresh && ourFile
+
+	return cachedBytes, nil
+}
+
+func (d *CachedDiscoveryClient) writeCachedFile(filename string, obj runtime.Object) error {
+	if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
+		return err
+	}
+
+	bytes, err := runtime.Encode(scheme.Codecs.LegacyCodec(), obj)
+	if err != nil {
+		return err
+	}
+
+	f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename)+".")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	_, err = f.Write(bytes)
+	if err != nil {
+		return err
+	}
+
+	err = os.Chmod(f.Name(), 0755)
+	if err != nil {
+		return err
+	}
+
+	name := f.Name()
+	err = f.Close()
+	if err != nil {
+		return err
+	}
+
+	// atomic rename
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+	err = os.Rename(name, filename)
+	if err == nil {
+		d.ourFiles[filename] = struct{}{}
+	}
+	return err
+}
+
+func (d *CachedDiscoveryClient) RESTClient() restclient.Interface {
+	return d.delegate.RESTClient()
+}
+
+func (d *CachedDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	return ServerPreferredResources(d)
+}
+
+func (d *CachedDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	return ServerPreferredNamespacedResources(d)
+}
+
+func (d *CachedDiscoveryClient) ServerVersion() (*version.Info, error) {
+	return d.delegate.ServerVersion()
+}
+
+func (d *CachedDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
+	return d.delegate.OpenAPISchema()
+}
+
+func (d *CachedDiscoveryClient) Fresh() bool {
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+
+	return d.fresh
+}
+
+func (d *CachedDiscoveryClient) Invalidate() {
+	d.mutex.Lock()
+	defer d.mutex.Unlock()
+
+	d.ourFiles = map[string]struct{}{}
+	d.fresh = true
+	d.invalidated = true
+}
+
+// NewCachedDiscoveryClientForConfig creates a new DiscoveryClient for the given config, and wraps
+// the created client in a CachedDiscoveryClient. The provided configuration is updated with a
+// custom transport that understands cache responses.
+// We receive two distinct cache directories for now, in order to preserve old behavior
+// which makes use of the --cache-dir flag value for storing cache data from the CacheRoundTripper,
+// and makes use of the hardcoded destination (~/.kube/cache/discovery/...) for storing
+// CachedDiscoveryClient cache data. If httpCacheDir is empty, the restconfig's transport will not
+// be updated with a roundtripper that understands cache responses.
+// If discoveryCacheDir is empty, cached server resource data will be looked up in the current directory.
+// TODO(juanvallejo): the value of "--cache-dir" should be honored. Consolidate discoveryCacheDir with httpCacheDir
+// so that server resources and http-cache data are stored in the same location, provided via config flags.
+func NewCachedDiscoveryClientForConfig(config *restclient.Config, discoveryCacheDir, httpCacheDir string, ttl time.Duration) (*CachedDiscoveryClient, error) {
+	if len(httpCacheDir) > 0 {
+		// update the given restconfig with a custom roundtripper that
+		// understands how to handle cache responses.
+		wt := config.WrapTransport
+		config.WrapTransport = func(rt http.RoundTripper) http.RoundTripper {
+			if wt != nil {
+				rt = wt(rt)
+			}
+			return newCacheRoundTripper(httpCacheDir, rt)
+		}
+	}
+
+	discoveryClient, err := NewDiscoveryClientForConfig(config)
+	if err != nil {
+		return nil, err
+	}
+
+	return newCachedDiscoveryClient(discoveryClient, discoveryCacheDir, ttl), nil
+}
+
+// NewCachedDiscoveryClient creates a new DiscoveryClient.  cacheDirectory is the directory where discovery docs are held.  It must be unique per host:port combination to work well.
+func newCachedDiscoveryClient(delegate DiscoveryInterface, cacheDirectory string, ttl time.Duration) *CachedDiscoveryClient {
+	return &CachedDiscoveryClient{
+		delegate:       delegate,
+		cacheDirectory: cacheDirectory,
+		ttl:            ttl,
+		ourFiles:       map[string]struct{}{},
+		fresh:          true,
+	}
+}
--- a/discovery/cached_discovery_test.go
+++ b/discovery/cached_discovery_test.go
@@ -0,0 +1,169 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package discovery
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/googleapis/gnostic/OpenAPIv2"
+	"github.com/stretchr/testify/assert"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/version"
+	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/rest/fake"
+)
+
+func TestCachedDiscoveryClient_Fresh(t *testing.T) {
+	assert := assert.New(t)
+
+	d, err := ioutil.TempDir("", "")
+	assert.NoError(err)
+	defer os.RemoveAll(d)
+
+	c := fakeDiscoveryClient{}
+	cdc := newCachedDiscoveryClient(&c, d, 60*time.Second)
+	assert.True(cdc.Fresh(), "should be fresh after creation")
+
+	cdc.ServerGroups()
+	assert.True(cdc.Fresh(), "should be fresh after groups call without cache")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerGroups()
+	assert.True(cdc.Fresh(), "should be fresh after another groups call")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should be fresh after resources call")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should be fresh after another resources call")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc = newCachedDiscoveryClient(&c, d, 60*time.Second)
+	cdc.ServerGroups()
+	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing groups cache")
+	assert.Equal(c.groupCalls, 1)
+
+	cdc.ServerResources()
+	assert.False(cdc.Fresh(), "should NOT be fresh after recreation with existing resources cache")
+	assert.Equal(c.resourceCalls, 1)
+
+	cdc.Invalidate()
+	assert.True(cdc.Fresh(), "should be fresh after cache invalidation")
+
+	cdc.ServerResources()
+	assert.True(cdc.Fresh(), "should ignore existing resources cache after invalidation")
+	assert.Equal(c.resourceCalls, 2)
+}
+
+func TestNewCachedDiscoveryClient_TTL(t *testing.T) {
+	assert := assert.New(t)
+
+	d, err := ioutil.TempDir("", "")
+	assert.NoError(err)
+	defer os.RemoveAll(d)
+
+	c := fakeDiscoveryClient{}
+	cdc := newCachedDiscoveryClient(&c, d, 1*time.Nanosecond)
+	cdc.ServerGroups()
+	assert.Equal(c.groupCalls, 1)
+
+	time.Sleep(1 * time.Second)
+
+	cdc.ServerGroups()
+	assert.Equal(c.groupCalls, 2)
+}
+
+type fakeDiscoveryClient struct {
+	groupCalls    int
+	resourceCalls int
+	versionCalls  int
+	openAPICalls  int
+
+	serverResourcesHandler func() ([]*metav1.APIResourceList, error)
+}
+
+var _ DiscoveryInterface = &fakeDiscoveryClient{}
+
+func (c *fakeDiscoveryClient) RESTClient() restclient.Interface {
+	return &fake.RESTClient{}
+}
+
+func (c *fakeDiscoveryClient) ServerGroups() (*metav1.APIGroupList, error) {
+	c.groupCalls = c.groupCalls + 1
+	return &metav1.APIGroupList{
+		Groups: []metav1.APIGroup{
+			{
+				Name: "a",
+				Versions: []metav1.GroupVersionForDiscovery{
+					{
+						GroupVersion: "a/v1",
+						Version:      "v1",
+					},
+				},
+				PreferredVersion: metav1.GroupVersionForDiscovery{
+					GroupVersion: "a/v1",
+					Version:      "v1",
+				},
+			},
+		},
+	}, nil
+}
+
+func (c *fakeDiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	if groupVersion == "a/v1" {
+		return &metav1.APIResourceList{APIResources: []metav1.APIResource{{Name: "widgets", Kind: "Widget"}}}, nil
+	}
+
+	return nil, errors.NewNotFound(schema.GroupResource{}, "")
+}
+
+func (c *fakeDiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	if c.serverResourcesHandler != nil {
+		return c.serverResourcesHandler()
+	}
+	return []*metav1.APIResourceList{}, nil
+}
+
+func (c *fakeDiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	return nil, nil
+}
+
+func (c *fakeDiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+	c.resourceCalls = c.resourceCalls + 1
+	return nil, nil
+}
+
+func (c *fakeDiscoveryClient) ServerVersion() (*version.Info, error) {
+	c.versionCalls = c.versionCalls + 1
+	return &version.Info{}, nil
+}
+
+func (c *fakeDiscoveryClient) OpenAPISchema() (*openapi_v2.Document, error) {
+	c.openAPICalls = c.openAPICalls + 1
+	return &openapi_v2.Document{}, nil
+}
--- a/discovery/discovery_client.go
+++ b/discovery/discovery_client.go
@@ -22,6 +22,7 @@ import (
 	"net/url"
 	"sort"
 	"strings"
+	"sync"
 	"time"

 	"github.com/golang/protobuf/proto"
@@ -32,6 +33,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
+	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/version"
 	"k8s.io/client-go/kubernetes/scheme"
 	restclient "k8s.io/client-go/rest"
@@ -42,12 +44,8 @@ const (
 	defaultRetries = 2
 	// protobuf mime type
 	mimePb = "application/com.github.proto-openapi.spec.v2@v1.0+protobuf"
-)
-
-var (
 	// defaultTimeout is the maximum amount of time per request when no timeout has been set on a RESTClient.
 	// Defaults to 32s in order to have a distinguishable length of time, relative to other timeouts that exist.
-	// It's a variable to be able to change it in tests.
 	defaultTimeout = 32 * time.Second
 )

@@ -191,33 +189,7 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r

 // serverResources returns the supported resources for all groups and versions.
 func (d *DiscoveryClient) serverResources() ([]*metav1.APIResourceList, error) {
-	apiGroups, err := d.ServerGroups()
-	if err != nil {
-		return nil, err
-	}
-
-	result := []*metav1.APIResourceList{}
-	failedGroups := make(map[schema.GroupVersion]error)
-
-	for _, apiGroup := range apiGroups.Groups {
-		for _, version := range apiGroup.Versions {
-			gv := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
-			resources, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
-			if err != nil {
-				// TODO: maybe restrict this to NotFound errors
-				failedGroups[gv] = err
-				continue
-			}
-
-			result = append(result, resources)
-		}
-	}
-
-	if len(failedGroups) == 0 {
-		return result, nil
-	}
-
-	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+	return ServerResources(d)
 }

 // ServerResources returns the supported resources for all groups and versions.
@@ -250,14 +222,46 @@ func IsGroupDiscoveryFailedError(err error) bool {

 // serverPreferredResources returns the supported resources with the version preferred by the server.
 func (d *DiscoveryClient) serverPreferredResources() ([]*metav1.APIResourceList, error) {
+	return ServerPreferredResources(d)
+}
+
+// ServerResources uses the provided discovery interface to look up supported resources for all groups and versions.
+func ServerResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
+	apiGroups, err := d.ServerGroups()
+	if err != nil {
+		return nil, err
+	}
+
+	groupVersionResources, failedGroups := fetchGroupVersionResources(d, apiGroups)
+
+	// order results by group/version discovery order
+	result := []*metav1.APIResourceList{}
+	for _, apiGroup := range apiGroups.Groups {
+		for _, version := range apiGroup.Versions {
+			gv := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+			if resources, ok := groupVersionResources[gv]; ok {
+				result = append(result, resources)
+			}
+		}
+	}
+
+	if len(failedGroups) == 0 {
+		return result, nil
+	}
+
+	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+}
+
+// ServerPreferredResources uses the provided discovery interface to look up preferred resources
+func ServerPreferredResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
 	serverGroupList, err := d.ServerGroups()
 	if err != nil {
 		return nil, err
 	}

-	result := []*metav1.APIResourceList{}
-	failedGroups := make(map[schema.GroupVersion]error)
+	groupVersionResources, failedGroups := fetchGroupVersionResources(d, serverGroupList)

+	result := []*metav1.APIResourceList{}
 	grVersions := map[schema.GroupResource]string{}                         // selected version of a GroupResource
 	grApiResources := map[schema.GroupResource]*metav1.APIResource{}        // selected APIResource for a GroupResource
 	gvApiResourceLists := map[schema.GroupVersion]*metav1.APIResourceList{} // blueprint for a APIResourceList for later grouping
@@ -265,10 +269,9 @@ func (d *DiscoveryClient) serverPreferredResources() ([]*metav1.APIResourceList,
 	for _, apiGroup := range serverGroupList.Groups {
 		for _, version := range apiGroup.Versions {
 			groupVersion := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
-			apiResourceList, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
-			if err != nil {
-				// TODO: maybe restrict this to NotFound errors
-				failedGroups[groupVersion] = err
+
+			apiResourceList, ok := groupVersionResources[groupVersion]
+			if !ok {
 				continue
 			}

@@ -310,6 +313,41 @@ func (d *DiscoveryClient) serverPreferredResources() ([]*metav1.APIResourceList,
 	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }

+// fetchServerResourcesForGroupVersions uses the discovery client to fetch the resources for the specified groups in parallel
+func fetchGroupVersionResources(d DiscoveryInterface, apiGroups *metav1.APIGroupList) (map[schema.GroupVersion]*metav1.APIResourceList, map[schema.GroupVersion]error) {
+	groupVersionResources := make(map[schema.GroupVersion]*metav1.APIResourceList)
+	failedGroups := make(map[schema.GroupVersion]error)
+
+	wg := &sync.WaitGroup{}
+	resultLock := &sync.Mutex{}
+	for _, apiGroup := range apiGroups.Groups {
+		for _, version := range apiGroup.Versions {
+			groupVersion := schema.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				defer utilruntime.HandleCrash()
+
+				apiResourceList, err := d.ServerResourcesForGroupVersion(groupVersion.String())
+
+				// lock to record results
+				resultLock.Lock()
+				defer resultLock.Unlock()
+
+				if err != nil {
+					// TODO: maybe restrict this to NotFound errors
+					failedGroups[groupVersion] = err
+				} else {
+					groupVersionResources[groupVersion] = apiResourceList
+				}
+			}()
+		}
+	}
+	wg.Wait()
+
+	return groupVersionResources, failedGroups
+}
+
 // ServerPreferredResources returns the supported resources with the version preferred by the
 // server.
 func (d *DiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
@@ -319,7 +357,12 @@ func (d *DiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList,
 // ServerPreferredNamespacedResources returns the supported namespaced resources with the
 // version preferred by the server.
 func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	all, err := d.ServerPreferredResources()
+	return ServerPreferredNamespacedResources(d)
+}
+
+// ServerPreferredNamespacedResources uses the provided discovery interface to look up preferred namespaced resources
+func ServerPreferredNamespacedResources(d DiscoveryInterface) ([]*metav1.APIResourceList, error) {
+	all, err := ServerPreferredResources(d)
 	return FilteredBy(ResourcePredicateFunc(func(groupVersion string, r *metav1.APIResource) bool {
 		return r.Namespaced
 	}), all), err
--- a/discovery/discovery_client_test.go
+++ b/discovery/discovery_client_test.go
@@ -23,15 +23,15 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"reflect"
-	"strings"
 	"testing"
-	"time"

 	"github.com/gogo/protobuf/proto"
 	"github.com/googleapis/gnostic/OpenAPIv2"
+	"github.com/stretchr/testify/assert"

 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/diff"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/version"
 	restclient "k8s.io/client-go/rest"
@@ -130,25 +130,11 @@ func TestGetServerGroupsWithBrokenServer(t *testing.T) {
 		}
 	}
 }
-func TestGetServerGroupsWithTimeout(t *testing.T) {
-	done := make(chan bool)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		// first we need to write headers, otherwise http client will complain about
-		// exceeding timeout awaiting headers, only after we can block the call
-		w.WriteHeader(http.StatusOK)
-		<-done
-	}))
-	defer server.Close()
-	defer close(done)
-	tmp := defaultTimeout
-	defaultTimeout = 2 * time.Second
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	_, err := client.ServerGroups()
-	if err == nil || !strings.Contains(err.Error(), "deadline") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	done <- true
-	defaultTimeout = tmp
+
+func TestTimeoutIsSet(t *testing.T) {
+	cfg := &restclient.Config{}
+	setDiscoveryDefaults(cfg)
+	assert.Equal(t, defaultTimeout, cfg.Timeout)
 }

 func TestGetServerResourcesWithV1Server(t *testing.T) {
@@ -204,6 +190,14 @@ func TestGetServerResources(t *testing.T) {
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
+	beta2 := metav1.APIResourceList{
+		GroupVersion: "extensions/v1beta2",
+		APIResources: []metav1.APIResource{
+			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
+			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
+			{Name: "jobs", Namespaced: true, Kind: "Job"},
+		},
+	}
 	tests := []struct {
 		resourcesList *metav1.APIResourceList
 		path          string
@@ -236,6 +230,8 @@ func TestGetServerResources(t *testing.T) {
 			list = &stable
 		case "/apis/extensions/v1beta1":
 			list = &beta
+		case "/apis/extensions/v1beta2":
+			list = &beta2
 		case "/api":
 			list = &metav1.APIVersions{
 				Versions: []string{
@@ -246,8 +242,10 @@ func TestGetServerResources(t *testing.T) {
 			list = &metav1.APIGroupList{
 				Groups: []metav1.APIGroup{
 					{
+						Name: "extensions",
 						Versions: []metav1.GroupVersionForDiscovery{
-							{GroupVersion: "extensions/v1beta1"},
+							{GroupVersion: "extensions/v1beta1", Version: "v1beta1"},
+							{GroupVersion: "extensions/v1beta2", Version: "v1beta2"},
 						},
 					},
 				},
@@ -289,11 +287,10 @@ func TestGetServerResources(t *testing.T) {
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	serverGroupVersions := sets.NewString(groupVersions(serverResources)...)
-	for _, api := range []string{"v1", "extensions/v1beta1"} {
-		if !serverGroupVersions.Has(api) {
-			t.Errorf("missing expected api %q in %v", api, serverResources)
-		}
+	serverGroupVersions := groupVersions(serverResources)
+	expectedGroupVersions := []string{"v1", "extensions/v1beta1", "extensions/v1beta2"}
+	if !reflect.DeepEqual(expectedGroupVersions, serverGroupVersions) {
+		t.Errorf("unexpected group versions: %v", diff.ObjectReflectDiff(expectedGroupVersions, serverGroupVersions))
 	}
 }

@@ -639,7 +636,7 @@ func TestServerPreferredResourcesRetries(t *testing.T) {
 						{
 							Name: "extensions",
 							Versions: []metav1.GroupVersionForDiscovery{
-								{GroupVersion: "extensions/v1beta1"},
+								{GroupVersion: "extensions/v1beta1", Version: "v1beta1"},
 							},
 							PreferredVersion: metav1.GroupVersionForDiscovery{
 								GroupVersion: "extensions/v1beta1",
--- a/discovery/round_tripper.go
+++ b/discovery/round_tripper.go
@@ -0,0 +1,51 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package transport provides a round tripper capable of caching HTTP responses.
+package discovery
+
+import (
+	"net/http"
+	"path/filepath"
+
+	"github.com/gregjones/httpcache"
+	"github.com/gregjones/httpcache/diskcache"
+	"github.com/peterbourgon/diskv"
+)
+
+type cacheRoundTripper struct {
+	rt *httpcache.Transport
+}
+
+// newCacheRoundTripper creates a roundtripper that reads the ETag on
+// response headers and send the If-None-Match header on subsequent
+// corresponding requests.
+func newCacheRoundTripper(cacheDir string, rt http.RoundTripper) http.RoundTripper {
+	d := diskv.New(diskv.Options{
+		BasePath: cacheDir,
+		TempDir:  filepath.Join(cacheDir, ".diskv-temp"),
+	})
+	t := httpcache.NewTransport(diskcache.NewWithDiskv(d))
+	t.Transport = rt
+
+	return &cacheRoundTripper{rt: t}
+}
+
+func (rt *cacheRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	return rt.rt.RoundTrip(req)
+}
+
+func (rt *cacheRoundTripper) WrappedRoundTripper() http.RoundTripper { return rt.rt.Transport }
--- a/discovery/round_tripper_test.go
+++ b/discovery/round_tripper_test.go
@@ -0,0 +1,95 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package discovery
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"testing"
+)
+
+// copied from k8s.io/client-go/transport/round_trippers_test.go
+type testRoundTripper struct {
+	Request  *http.Request
+	Response *http.Response
+	Err      error
+}
+
+func (rt *testRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	rt.Request = req
+	return rt.Response, rt.Err
+}
+
+func TestCacheRoundTripper(t *testing.T) {
+	rt := &testRoundTripper{}
+	cacheDir, err := ioutil.TempDir("", "cache-rt")
+	defer os.RemoveAll(cacheDir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cache := newCacheRoundTripper(cacheDir, rt)
+
+	// First call, caches the response
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL:    &url.URL{Host: "localhost"},
+	}
+	rt.Response = &http.Response{
+		Header:     http.Header{"ETag": []string{`"123456"`}},
+		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Content"))),
+		StatusCode: http.StatusOK,
+	}
+	resp, err := cache.RoundTrip(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	content, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "Content" {
+		t.Errorf(`Expected Body to be "Content", got %q`, string(content))
+	}
+
+	// Second call, returns cached response
+	req = &http.Request{
+		Method: http.MethodGet,
+		URL:    &url.URL{Host: "localhost"},
+	}
+	rt.Response = &http.Response{
+		StatusCode: http.StatusNotModified,
+		Body:       ioutil.NopCloser(bytes.NewReader([]byte("Other Content"))),
+	}
+
+	resp, err = cache.RoundTrip(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Read body and make sure we have the initial content
+	content, err = ioutil.ReadAll(resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "Content" {
+		t.Errorf("Invalid content read from cache %q", string(content))
+	}
+}
--- a/discovery/unstructured.go
+++ b/discovery/unstructured.go
@@ -26,31 +26,17 @@ import (
 // UnstructuredObjectTyper provides a runtime.ObjectTyper implementation for
 // runtime.Unstructured object based on discovery information.
 type UnstructuredObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
-	typers     []runtime.ObjectTyper
+	typers []runtime.ObjectTyper
 }

 // NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
 // unstructured objects based on discovery information. It accepts a list of fallback typers
 // for handling objects that are not runtime.Unstructured. It does not delegate the Recognizes
 // check, only ObjectKinds.
-func NewUnstructuredObjectTyper(groupResources []*APIGroupResources, typers ...runtime.ObjectTyper) *UnstructuredObjectTyper {
+// TODO this only works for the apiextensions server and doesn't recognize any types.  Move to point of use.
+func NewUnstructuredObjectTyper(typers ...runtime.ObjectTyper) *UnstructuredObjectTyper {
 	dot := &UnstructuredObjectTyper{
-		registered: make(map[schema.GroupVersionKind]bool),
-		typers:     typers,
-	}
-	for _, group := range groupResources {
-		for _, discoveryVersion := range group.Group.Versions {
-			resources, ok := group.VersionedResources[discoveryVersion.Version]
-			if !ok {
-				continue
-			}
-
-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			for _, resource := range resources {
-				dot.registered[gv.WithKind(resource.Kind)] = true
-			}
-		}
+		typers: typers,
 	}
 	return dot
 }
@@ -89,7 +75,7 @@ func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []schema
 // Recognizes returns true if the provided group,version,kind was in the
 // discovery information.
 func (d *UnstructuredObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
-	return d.registered[gvk]
+	return false
 }

 var _ runtime.ObjectTyper = &UnstructuredObjectTyper{}
--- a/dynamic/client_test.go
+++ b/dynamic/client_test.go
@@ -58,12 +58,11 @@ func getObject(version, kind, name string) *unstructured.Unstructured {
 	}
 }

-func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
+func getClientServer(h func(http.ResponseWriter, *http.Request)) (Interface, *httptest.Server, error) {
 	srv := httptest.NewServer(http.HandlerFunc(h))
-	cl, err := NewClient(&restclient.Config{
-		Host:          srv.URL,
-		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
-	}, *gv)
+	cl, err := NewForConfig(&restclient.Config{
+		Host: srv.URL,
+	})
 	if err != nil {
 		srv.Close()
 		return nil, nil, err
@@ -116,9 +115,8 @@ func TestList(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("List(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -136,7 +134,7 @@ func TestList(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
+		got, err := cl.Resource(resource).Namespace(tc.namespace).List(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
 			continue
@@ -150,12 +148,13 @@ func TestList(t *testing.T) {

 func TestGet(t *testing.T) {
 	tcs := []struct {
-		resource  string
-		namespace string
-		name      string
-		path      string
-		resp      []byte
-		want      *unstructured.Unstructured
+		resource    string
+		subresource []string
+		namespace   string
+		name        string
+		path        string
+		resp        []byte
+		want        *unstructured.Unstructured
 	}{
 		{
 			resource: "rtest",
@@ -173,25 +172,26 @@ func TestGet(t *testing.T) {
 			want:      getObject("vTest", "rTest", "namespaced_get"),
 		},
 		{
-			resource: "rtest/srtest",
-			name:     "normal_subresource_get",
-			path:     "/apis/gtest/vtest/rtest/normal_subresource_get/srtest",
-			resp:     getJSON("vTest", "srTest", "normal_subresource_get"),
-			want:     getObject("vTest", "srTest", "normal_subresource_get"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "normal_subresource_get",
+			path:        "/apis/gtest/vtest/rtest/normal_subresource_get/srtest",
+			resp:        getJSON("vTest", "srTest", "normal_subresource_get"),
+			want:        getObject("vTest", "srTest", "normal_subresource_get"),
 		},
 		{
-			resource:  "rtest/srtest",
-			namespace: "nstest",
-			name:      "namespaced_subresource_get",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
-			resp:      getJSON("vTest", "srTest", "namespaced_subresource_get"),
-			want:      getObject("vTest", "srTest", "namespaced_subresource_get"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			namespace:   "nstest",
+			name:        "namespaced_subresource_get",
+			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_get/srtest",
+			resp:        getJSON("vTest", "srTest", "namespaced_subresource_get"),
+			want:        getObject("vTest", "srTest", "namespaced_subresource_get"),
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -209,7 +209,7 @@ func TestGet(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).Get(tc.name, metav1.GetOptions{})
+		got, err := cl.Resource(resource).Namespace(tc.namespace).Get(tc.name, metav1.GetOptions{}, tc.subresource...)
 		if err != nil {
 			t.Errorf("unexpected error when getting %q: %v", tc.name, err)
 			continue
@@ -230,6 +230,7 @@ func TestDelete(t *testing.T) {
 		Status:   metav1.StatusSuccess,
 	}
 	tcs := []struct {
+		subresource   []string
 		namespace     string
 		name          string
 		path          string
@@ -244,6 +245,17 @@ func TestDelete(t *testing.T) {
 			name:      "namespaced_delete",
 			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete",
 		},
+		{
+			subresource: []string{"srtest"},
+			name:        "normal_delete",
+			path:        "/apis/gtest/vtest/rtest/normal_delete/srtest",
+		},
+		{
+			subresource: []string{"srtest"},
+			namespace:   "nstest",
+			name:        "namespaced_delete",
+			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_delete/srtest",
+		},
 		{
 			namespace:     "nstest",
 			name:          "namespaced_delete_with_options",
@@ -252,9 +264,8 @@ func TestDelete(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("Delete(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
 			}
@@ -272,7 +283,7 @@ func TestDelete(t *testing.T) {
 		}
 		defer srv.Close()

-		err = cl.Resource(resource, tc.namespace).Delete(tc.name, tc.deleteOptions)
+		err = cl.Resource(resource).Namespace(tc.namespace).Delete(tc.name, tc.deleteOptions, tc.subresource...)
 		if err != nil {
 			t.Errorf("unexpected error when deleting %q: %v", tc.name, err)
 			continue
@@ -301,9 +312,8 @@ func TestDeleteCollection(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "DELETE" {
 				t.Errorf("DeleteCollection(%q) got HTTP method %s. wanted DELETE", tc.name, r.Method)
 			}
@@ -321,7 +331,7 @@ func TestDeleteCollection(t *testing.T) {
 		}
 		defer srv.Close()

-		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
+		err = cl.Resource(resource).Namespace(tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
 			continue
@@ -331,11 +341,12 @@ func TestDeleteCollection(t *testing.T) {

 func TestCreate(t *testing.T) {
 	tcs := []struct {
-		resource  string
-		name      string
-		namespace string
-		obj       *unstructured.Unstructured
-		path      string
+		resource    string
+		subresource []string
+		name        string
+		namespace   string
+		obj         *unstructured.Unstructured
+		path        string
 	}{
 		{
 			resource: "rtest",
@@ -350,11 +361,25 @@ func TestCreate(t *testing.T) {
 			path:      "/apis/gtest/vtest/namespaces/nstest/rtest",
 			obj:       getObject("gtest/vTest", "rTest", "namespaced_create"),
 		},
+		{
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "normal_subresource_create",
+			path:        "/apis/gtest/vtest/rtest/normal_subresource_create/srtest",
+			obj:         getObject("vTest", "srTest", "normal_subresource_create"),
+		},
+		{
+			resource:    "rtest/",
+			subresource: []string{"srtest"},
+			name:        "namespaced_subresource_create",
+			namespace:   "nstest",
+			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_create/srtest",
+			obj:         getObject("vTest", "srTest", "namespaced_subresource_create"),
+		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "POST" {
 				t.Errorf("Create(%q) got HTTP method %s. wanted POST", tc.name, r.Method)
 			}
@@ -379,7 +404,7 @@ func TestCreate(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).Create(tc.obj)
+		got, err := cl.Resource(resource).Namespace(tc.namespace).Create(tc.obj, tc.subresource...)
 		if err != nil {
 			t.Errorf("unexpected error when creating %q: %v", tc.name, err)
 			continue
@@ -393,11 +418,12 @@ func TestCreate(t *testing.T) {

 func TestUpdate(t *testing.T) {
 	tcs := []struct {
-		resource  string
-		name      string
-		namespace string
-		obj       *unstructured.Unstructured
-		path      string
+		resource    string
+		subresource []string
+		name        string
+		namespace   string
+		obj         *unstructured.Unstructured
+		path        string
 	}{
 		{
 			resource: "rtest",
@@ -413,23 +439,24 @@ func TestUpdate(t *testing.T) {
 			obj:       getObject("gtest/vTest", "rTest", "namespaced_update"),
 		},
 		{
-			resource: "rtest/srtest",
-			name:     "normal_subresource_update",
-			path:     "/apis/gtest/vtest/rtest/normal_update/srtest",
-			obj:      getObject("gtest/vTest", "srTest", "normal_update"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "normal_subresource_update",
+			path:        "/apis/gtest/vtest/rtest/normal_update/srtest",
+			obj:         getObject("gtest/vTest", "srTest", "normal_update"),
 		},
 		{
-			resource:  "rtest/srtest",
-			name:      "namespaced_subresource_update",
-			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
-			obj:       getObject("gtest/vTest", "srTest", "namespaced_update"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "namespaced_subresource_update",
+			namespace:   "nstest",
+			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_update/srtest",
+			obj:         getObject("gtest/vTest", "srTest", "namespaced_update"),
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PUT" {
 				t.Errorf("Update(%q) got HTTP method %s. wanted PUT", tc.name, r.Method)
 			}
@@ -454,7 +481,7 @@ func TestUpdate(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).Update(tc.obj)
+		got, err := cl.Resource(resource).Namespace(tc.namespace).Update(tc.obj, tc.subresource...)
 		if err != nil {
 			t.Errorf("unexpected error when updating %q: %v", tc.name, err)
 			continue
@@ -497,9 +524,8 @@ func TestWatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: "rtest"}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "GET" {
 				t.Errorf("Watch(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
 			}
@@ -511,7 +537,7 @@ func TestWatch(t *testing.T) {
 				t.Errorf("Watch(%q) got query %s. wanted %s", tc.name, r.URL.RawQuery, tc.query)
 			}

-			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, unstructured.UnstructuredJSONScheme), unstructured.UnstructuredJSONScheme)
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}
@@ -522,7 +548,7 @@ func TestWatch(t *testing.T) {
 		}
 		defer srv.Close()

-		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
+		watcher, err := cl.Resource(resource).Namespace(tc.namespace).Watch(metav1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
 			continue
@@ -539,12 +565,13 @@ func TestWatch(t *testing.T) {

 func TestPatch(t *testing.T) {
 	tcs := []struct {
-		resource  string
-		name      string
-		namespace string
-		patch     []byte
-		want      *unstructured.Unstructured
-		path      string
+		resource    string
+		subresource []string
+		name        string
+		namespace   string
+		patch       []byte
+		want        *unstructured.Unstructured
+		path        string
 	}{
 		{
 			resource: "rtest",
@@ -562,25 +589,26 @@ func TestPatch(t *testing.T) {
 			want:      getObject("gtest/vTest", "rTest", "namespaced_patch"),
 		},
 		{
-			resource: "rtest/srtest",
-			name:     "normal_subresource_patch",
-			path:     "/apis/gtest/vtest/rtest/normal_subresource_patch/srtest",
-			patch:    getJSON("gtest/vTest", "srTest", "normal_subresource_patch"),
-			want:     getObject("gtest/vTest", "srTest", "normal_subresource_patch"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "normal_subresource_patch",
+			path:        "/apis/gtest/vtest/rtest/normal_subresource_patch/srtest",
+			patch:       getJSON("gtest/vTest", "srTest", "normal_subresource_patch"),
+			want:        getObject("gtest/vTest", "srTest", "normal_subresource_patch"),
 		},
 		{
-			resource:  "rtest/srtest",
-			name:      "namespaced_subresource_patch",
-			namespace: "nstest",
-			path:      "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
-			patch:     getJSON("gtest/vTest", "srTest", "namespaced_subresource_patch"),
-			want:      getObject("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+			resource:    "rtest",
+			subresource: []string{"srtest"},
+			name:        "namespaced_subresource_patch",
+			namespace:   "nstest",
+			path:        "/apis/gtest/vtest/namespaces/nstest/rtest/namespaced_subresource_patch/srtest",
+			patch:       getJSON("gtest/vTest", "srTest", "namespaced_subresource_patch"),
+			want:        getObject("gtest/vTest", "srTest", "namespaced_subresource_patch"),
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: tc.resource, Namespaced: len(tc.namespace) != 0}
-		cl, srv, err := getClientServer(gv, func(w http.ResponseWriter, r *http.Request) {
+		resource := schema.GroupVersionResource{Group: "gtest", Version: "vtest", Resource: tc.resource}
+		cl, srv, err := getClientServer(func(w http.ResponseWriter, r *http.Request) {
 			if r.Method != "PATCH" {
 				t.Errorf("Patch(%q) got HTTP method %s. wanted PATCH", tc.name, r.Method)
 			}
@@ -610,7 +638,7 @@ func TestPatch(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch)
+		got, err := cl.Resource(resource).Namespace(tc.namespace).Patch(tc.name, types.StrategicMergePatchType, tc.patch, tc.subresource...)
 		if err != nil {
 			t.Errorf("unexpected error when patching %q: %v", tc.name, err)
 			continue
--- a/dynamic/dynamic_util.go
+++ b/dynamic/dynamic_util.go
@@ -1,87 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package dynamic
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
-func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList) (*meta.DefaultRESTMapper, error) {
-	rm := meta.NewDefaultRESTMapper(nil)
-	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
-		if err != nil {
-			return nil, err
-		}
-
-		for _, resource := range resourceList.APIResources {
-			gvk := gv.WithKind(resource.Kind)
-			scope := meta.RESTScopeRoot
-			if resource.Namespaced {
-				scope = meta.RESTScopeNamespace
-			}
-			rm.Add(gvk, scope)
-		}
-	}
-	return rm, nil
-}
-
-// ObjectTyper provides an ObjectTyper implementation for
-// unstructured.Unstructured object based on discovery information.
-type ObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
-}
-
-// NewObjectTyper constructs an ObjectTyper from discovery information.
-func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, error) {
-	ot := &ObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
-	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
-		if err != nil {
-			return nil, err
-		}
-
-		for _, resource := range resourceList.APIResources {
-			ot.registered[gv.WithKind(resource.Kind)] = true
-		}
-	}
-	return ot, nil
-}
-
-// ObjectKinds returns a slice of one element with the
-// group,version,kind of the provided object, or an error if the
-// object is not *unstructured.Unstructured or has no group,version,kind
-// information.
-func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]schema.GroupVersionKind, bool, error) {
-	if _, ok := obj.(*unstructured.Unstructured); !ok {
-		return nil, false, fmt.Errorf("type %T is invalid for determining dynamic object types", obj)
-	}
-	return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
-}
-
-// Recognizes returns true if the provided group,version,kind was in
-// the discovery information.
-func (ot *ObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
-	return ot.registered[gvk]
-}
--- a/dynamic/dynamic_util_test.go
+++ b/dynamic/dynamic_util_test.go
@@ -1,79 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package dynamic
-
-import (
-	"testing"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-func TestDiscoveryRESTMapper(t *testing.T) {
-	resources := []*metav1.APIResourceList{
-		{
-			GroupVersion: "test/beta1",
-			APIResources: []metav1.APIResource{
-				{
-					Name:       "test_kinds",
-					Namespaced: true,
-					Kind:       "test_kind",
-				},
-			},
-		},
-	}
-
-	gvk := schema.GroupVersionKind{
-		Group:   "test",
-		Version: "beta1",
-		Kind:    "test_kind",
-	}
-
-	mapper, err := NewDiscoveryRESTMapper(resources)
-	if err != nil {
-		t.Fatalf("unexpected error creating mapper: %s", err)
-	}
-
-	for _, res := range []schema.GroupVersionResource{
-		{
-			Group:    "test",
-			Version:  "beta1",
-			Resource: "test_kinds",
-		},
-		{
-			Version:  "beta1",
-			Resource: "test_kinds",
-		},
-		{
-			Group:    "test",
-			Resource: "test_kinds",
-		},
-		{
-			Resource: "test_kinds",
-		},
-	} {
-		got, err := mapper.KindFor(res)
-		if err != nil {
-			t.Errorf("KindFor(%#v) unexpected error: %s", res, err)
-			continue
-		}
-
-		if got != gvk {
-			t.Errorf("KindFor(%#v) = %#v; want %#v", res, got, gvk)
-		}
-	}
-}
--- a/dynamic/fake/client.go
+++ b/dynamic/fake/client.go
@@ -1,163 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Package fake provides a fake client interface to arbitrary Kubernetes
-// APIs that exposes common high level operations and exposes common
-// metadata.
-package fake
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/labels"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/testing"
-	"k8s.io/client-go/util/flowcontrol"
-)
-
-// FakeClient is a fake implementation of dynamic.Interface.
-type FakeClient struct {
-	GroupVersion schema.GroupVersion
-
-	*testing.Fake
-}
-
-// GetRateLimiter returns the rate limiter for this client.
-func (c *FakeClient) GetRateLimiter() flowcontrol.RateLimiter {
-	return nil
-}
-
-// Resource returns an API interface to the specified resource for this client's
-// group and version.  If resource is not a namespaced resource, then namespace
-// is ignored.  The ResourceClient inherits the parameter codec of this client
-func (c *FakeClient) Resource(resource *metav1.APIResource, namespace string) dynamic.ResourceInterface {
-	return &FakeResourceClient{
-		Resource:  c.GroupVersion.WithResource(resource.Name),
-		Kind:      c.GroupVersion.WithKind(resource.Kind),
-		Namespace: namespace,
-
-		Fake: c.Fake,
-	}
-}
-
-// ParameterCodec returns a client with the provided parameter codec.
-func (c *FakeClient) ParameterCodec(parameterCodec runtime.ParameterCodec) dynamic.Interface {
-	return &FakeClient{
-		Fake: c.Fake,
-	}
-}
-
-// FakeResourceClient is a fake implementation of dynamic.ResourceInterface
-type FakeResourceClient struct {
-	Resource  schema.GroupVersionResource
-	Kind      schema.GroupVersionKind
-	Namespace string
-
-	*testing.Fake
-}
-
-// List returns a list of objects for this resource.
-func (c *FakeResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewListAction(c.Resource, c.Kind, c.Namespace, opts), &unstructured.UnstructuredList{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	label, _, _ := testing.ExtractFromListOptions(opts)
-	if label == nil {
-		label = labels.Everything()
-	}
-	list := &unstructured.UnstructuredList{}
-	for _, item := range obj.(*unstructured.UnstructuredList).Items {
-		if label.Matches(labels.Set(item.GetLabels())) {
-			list.Items = append(list.Items, item)
-		}
-	}
-	return list, err
-}
-
-// Get gets the resource with the specified name.
-func (c *FakeResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewGetAction(c.Resource, c.Namespace, name), &unstructured.Unstructured{})
-
-	if obj == nil {
-		return nil, err
-	}
-
-	return obj.(*unstructured.Unstructured), err
-}
-
-// Delete deletes the resource with the specified name.
-func (c *FakeResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteAction(c.Resource, c.Namespace, name), &unstructured.Unstructured{})
-
-	return err
-}
-
-// DeleteCollection deletes a collection of objects.
-func (c *FakeResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	_, err := c.Fake.
-		Invokes(testing.NewDeleteCollectionAction(c.Resource, c.Namespace, listOptions), &unstructured.Unstructured{})
-
-	return err
-}
-
-// Create creates the provided resource.
-func (c *FakeResourceClient) Create(inObj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewCreateAction(c.Resource, c.Namespace, inObj), &unstructured.Unstructured{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*unstructured.Unstructured), err
-}
-
-// Update updates the provided resource.
-func (c *FakeResourceClient) Update(inObj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewUpdateAction(c.Resource, c.Namespace, inObj), &unstructured.Unstructured{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*unstructured.Unstructured), err
-}
-
-// Watch returns a watch.Interface that watches the resource.
-func (c *FakeResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
-	return c.Fake.
-		InvokesWatch(testing.NewWatchAction(c.Resource, c.Namespace, opts))
-}
-
-// Patch patches the provided resource.
-func (c *FakeResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
-	obj, err := c.Fake.
-		Invokes(testing.NewPatchAction(c.Resource, c.Namespace, name, data), &unstructured.Unstructured{})
-
-	if obj == nil {
-		return nil, err
-	}
-	return obj.(*unstructured.Unstructured), err
-}
--- a/dynamic/fake/client_pool.go
+++ b/dynamic/fake/client_pool.go
@@ -1,48 +0,0 @@
-/*
-Copyright 2017 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Package fake provides a fake client interface to arbitrary Kubernetes
-// APIs that exposes common high level operations and exposes common
-// metadata.
-package fake
-
-import (
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/testing"
-)
-
-// FakeClientPool provides a fake implementation of dynamic.ClientPool.
-// It assumes resource GroupVersions are the same as their corresponding kind GroupVersions.
-type FakeClientPool struct {
-	testing.Fake
-}
-
-// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
-// Resource may be empty.
-func (p *FakeClientPool) ClientForGroupVersionResource(resource schema.GroupVersionResource) (dynamic.Interface, error) {
-	return p.ClientForGroupVersionKind(resource.GroupVersion().WithKind(""))
-}
-
-// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
-// Kind may be empty.
-func (p *FakeClientPool) ClientForGroupVersionKind(kind schema.GroupVersionKind) (dynamic.Interface, error) {
-	// we can just create a new client every time for testing purposes
-	return &FakeClient{
-		GroupVersion: kind.GroupVersion(),
-		Fake:         &p.Fake,
-	}, nil
-}
--- a/dynamic/fake/simple.go
+++ b/dynamic/fake/simple.go
@@ -17,6 +17,8 @@ limitations under the License.
 package fake

 import (
+	"strings"
+
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -63,37 +65,54 @@ type FakeDynamicClient struct {
 }

 type dynamicResourceClient struct {
-	client      *FakeDynamicClient
-	namespace   string
-	resource    schema.GroupVersionResource
-	subresource string
+	client    *FakeDynamicClient
+	namespace string
+	resource  schema.GroupVersionResource
 }

-var _ dynamic.DynamicInterface = &FakeDynamicClient{}
+var _ dynamic.Interface = &FakeDynamicClient{}

-func (c *FakeDynamicClient) Resource(resource schema.GroupVersionResource) dynamic.NamespaceableDynamicResourceInterface {
+func (c *FakeDynamicClient) Resource(resource schema.GroupVersionResource) dynamic.NamespaceableResourceInterface {
 	return &dynamicResourceClient{client: c, resource: resource}
 }

-// Deprecated, this isn't how we want to do it
-func (c *FakeDynamicClient) ClusterSubresource(resource schema.GroupVersionResource, subresource string) dynamic.DynamicResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource, subresource: subresource}
-}
-
-// Deprecated, this isn't how we want to do it
-func (c *FakeDynamicClient) NamespacedSubresource(resource schema.GroupVersionResource, subresource, namespace string) dynamic.DynamicResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource, namespace: namespace, subresource: subresource}
-}
-
-func (c *dynamicResourceClient) Namespace(ns string) dynamic.DynamicResourceInterface {
+func (c *dynamicResourceClient) Namespace(ns string) dynamic.ResourceInterface {
 	ret := *c
 	ret.namespace = ns
 	return &ret
 }

-func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	uncastRet, err := c.client.Fake.
-		Invokes(testing.NewCreateAction(c.resource, c.namespace, obj), obj)
+func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error) {
+	var uncastRet runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootCreateAction(c.resource, obj), obj)
+
+	case len(c.namespace) == 0 && len(subresources) > 0:
+		accessor, err := meta.Accessor(obj)
+		if err != nil {
+			return nil, err
+		}
+		name := accessor.GetName()
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootCreateSubresourceAction(c.resource, name, strings.Join(subresources, "/"), obj), obj)
+
+	case len(c.namespace) > 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewCreateAction(c.resource, c.namespace, obj), obj)
+
+	case len(c.namespace) > 0 && len(subresources) > 0:
+		accessor, err := meta.Accessor(obj)
+		if err != nil {
+			return nil, err
+		}
+		name := accessor.GetName()
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewCreateSubresourceAction(c.resource, name, strings.Join(subresources, "/"), c.namespace, obj), obj)
+
+	}

 	if err != nil {
 		return nil, err
@@ -109,9 +128,27 @@ func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured) (*unstruc
 	return ret, err
 }

-func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	uncastRet, err := c.client.Fake.
-		Invokes(testing.NewUpdateAction(c.resource, c.namespace, obj), obj)
+func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error) {
+	var uncastRet runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootUpdateAction(c.resource, obj), obj)
+
+	case len(c.namespace) == 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootUpdateSubresourceAction(c.resource, strings.Join(subresources, "/"), obj), obj)
+
+	case len(c.namespace) > 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewUpdateAction(c.resource, c.namespace, obj), obj)
+
+	case len(c.namespace) > 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewUpdateSubresourceAction(c.resource, strings.Join(subresources, "/"), c.namespace, obj), obj)
+
+	}

 	if err != nil {
 		return nil, err
@@ -128,8 +165,18 @@ func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured) (*unstruc
 }

 func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	uncastRet, err := c.client.Fake.
-		Invokes(testing.NewUpdateSubresourceAction(c.resource, "status", c.namespace, obj), obj)
+	var uncastRet runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootUpdateSubresourceAction(c.resource, "status", obj), obj)
+
+	case len(c.namespace) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewUpdateSubresourceAction(c.resource, "status", c.namespace, obj), obj)
+
+	}

 	if err != nil {
 		return nil, err
@@ -145,23 +192,65 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured) (*u
 	return ret, err
 }

-func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
-	_, err := c.client.Fake.
-		Invokes(testing.NewDeleteAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic delete fail"})
+func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions, subresources ...string) error {
+	var err error
+	switch {
+	case len(c.namespace) == 0 && len(subresources) == 0:
+		_, err = c.client.Fake.
+			Invokes(testing.NewRootDeleteAction(c.resource, name), &metav1.Status{Status: "dynamic delete fail"})
+
+	case len(c.namespace) == 0 && len(subresources) > 0:
+		_, err = c.client.Fake.
+			Invokes(testing.NewRootDeleteSubresourceAction(c.resource, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic delete fail"})
+
+	case len(c.namespace) > 0 && len(subresources) == 0:
+		_, err = c.client.Fake.
+			Invokes(testing.NewDeleteAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic delete fail"})
+
+	case len(c.namespace) > 0 && len(subresources) > 0:
+		_, err = c.client.Fake.
+			Invokes(testing.NewDeleteSubresourceAction(c.resource, strings.Join(subresources, "/"), c.namespace, name), &metav1.Status{Status: "dynamic delete fail"})
+	}

 	return err
 }

 func (c *dynamicResourceClient) DeleteCollection(opts *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(c.resource, c.namespace, listOptions)
+	var err error
+	switch {
+	case len(c.namespace) == 0:
+		action := testing.NewRootDeleteCollectionAction(c.resource, listOptions)
+		_, err = c.client.Fake.Invokes(action, &metav1.Status{Status: "dynamic deletecollection fail"})
+
+	case len(c.namespace) > 0:
+		action := testing.NewDeleteCollectionAction(c.resource, c.namespace, listOptions)
+		_, err = c.client.Fake.Invokes(action, &metav1.Status{Status: "dynamic deletecollection fail"})
+
+	}

-	_, err := c.client.Fake.Invokes(action, &metav1.Status{Status: "dynamic deletecollection fail"})
 	return err
 }

-func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
-	uncastRet, err := c.client.Fake.
-		Invokes(testing.NewGetAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic get fail"})
+func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error) {
+	var uncastRet runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootGetAction(c.resource, name), &metav1.Status{Status: "dynamic get fail"})
+
+	case len(c.namespace) == 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootGetSubresourceAction(c.resource, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic get fail"})
+
+	case len(c.namespace) > 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewGetAction(c.resource, c.namespace, name), &metav1.Status{Status: "dynamic get fail"})
+
+	case len(c.namespace) > 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewGetSubresourceAction(c.resource, c.namespace, strings.Join(subresources, "/"), name), &metav1.Status{Status: "dynamic get fail"})
+	}

 	if err != nil {
 		return nil, err
@@ -178,8 +267,18 @@ func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions) (*unstr
 }

 func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.UnstructuredList, error) {
-	obj, err := c.client.Fake.
-		Invokes(testing.NewListAction(c.resource, schema.GroupVersionKind{Version: "v1", Kind: "List"}, c.namespace, opts), &metav1.Status{Status: "dynamic list fail"})
+	var obj runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0:
+		obj, err = c.client.Fake.
+			Invokes(testing.NewRootListAction(c.resource, schema.GroupVersionKind{Version: "v1", Kind: "List"}, opts), &metav1.Status{Status: "dynamic list fail"})
+
+	case len(c.namespace) > 0:
+		obj, err = c.client.Fake.
+			Invokes(testing.NewListAction(c.resource, schema.GroupVersionKind{Version: "v1", Kind: "List"}, c.namespace, opts), &metav1.Status{Status: "dynamic list fail"})
+
+	}

 	if obj == nil {
 		return nil, err
@@ -213,13 +312,41 @@ func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.Uns
 }

 func (c *dynamicResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
-	return c.client.Fake.
-		InvokesWatch(testing.NewWatchAction(c.resource, c.namespace, opts))
+	switch {
+	case len(c.namespace) == 0:
+		return c.client.Fake.
+			InvokesWatch(testing.NewRootWatchAction(c.resource, opts))
+
+	case len(c.namespace) > 0:
+		return c.client.Fake.
+			InvokesWatch(testing.NewWatchAction(c.resource, c.namespace, opts))
+
+	}
+
+	panic("math broke")
 }

 func (c *dynamicResourceClient) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*unstructured.Unstructured, error) {
-	uncastRet, err := c.client.Fake.
-		Invokes(testing.NewPatchSubresourceAction(c.resource, c.namespace, name, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
+	var uncastRet runtime.Object
+	var err error
+	switch {
+	case len(c.namespace) == 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootPatchAction(c.resource, name, data), &metav1.Status{Status: "dynamic patch fail"})
+
+	case len(c.namespace) == 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewRootPatchSubresourceAction(c.resource, name, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
+
+	case len(c.namespace) > 0 && len(subresources) == 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewPatchAction(c.resource, c.namespace, name, data), &metav1.Status{Status: "dynamic patch fail"})
+
+	case len(c.namespace) > 0 && len(subresources) > 0:
+		uncastRet, err = c.client.Fake.
+			Invokes(testing.NewPatchSubresourceAction(c.resource, c.namespace, name, data, subresources...), &metav1.Status{Status: "dynamic patch fail"})
+
+	}

 	if err != nil {
 		return nil, err
--- a/dynamic/interface.go
+++ b/dynamic/interface.go
@@ -0,0 +1,59 @@
+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package dynamic
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/watch"
+)
+
+type Interface interface {
+	Resource(resource schema.GroupVersionResource) NamespaceableResourceInterface
+}
+
+type ResourceInterface interface {
+	Create(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error)
+	Update(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error)
+	UpdateStatus(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
+	Delete(name string, options *metav1.DeleteOptions, subresources ...string) error
+	DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error
+	Get(name string, options metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error)
+	List(opts metav1.ListOptions) (*unstructured.UnstructuredList, error)
+	Watch(opts metav1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*unstructured.Unstructured, error)
+}
+
+type NamespaceableResourceInterface interface {
+	Namespace(string) ResourceInterface
+	ResourceInterface
+}
+
+// APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is optional.
+// TODO find a better place to move this for existing callers
+type APIPathResolverFunc func(kind schema.GroupVersionKind) string
+
+// LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
+// TODO find a better place to move this for existing callers
+func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
+	if len(kind.Group) == 0 {
+		return "/api"
+	}
+	return "/apis"
+}
--- a/dynamic/simple.go
+++ b/dynamic/simple.go
@@ -17,7 +17,6 @@ limitations under the License.
 package dynamic

 import (
-	"fmt"
 	"io"

 	"k8s.io/apimachinery/pkg/api/meta"
@@ -31,39 +30,13 @@ import (
 	"k8s.io/client-go/rest"
 )

-type DynamicInterface interface {
-	Resource(resource schema.GroupVersionResource) NamespaceableDynamicResourceInterface
-
-	// Deprecated, this isn't how we want to do it
-	ClusterSubresource(resource schema.GroupVersionResource, subresource string) DynamicResourceInterface
-	// Deprecated, this isn't how we want to do it
-	NamespacedSubresource(resource schema.GroupVersionResource, subresource, namespace string) DynamicResourceInterface
-}
-
-type DynamicResourceInterface interface {
-	Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
-	Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
-	UpdateStatus(obj *unstructured.Unstructured) (*unstructured.Unstructured, error)
-	Delete(name string, options *metav1.DeleteOptions) error
-	DeleteCollection(options *metav1.DeleteOptions, listOptions metav1.ListOptions) error
-	Get(name string, options metav1.GetOptions) (*unstructured.Unstructured, error)
-	List(opts metav1.ListOptions) (*unstructured.UnstructuredList, error)
-	Watch(opts metav1.ListOptions) (watch.Interface, error)
-	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*unstructured.Unstructured, error)
-}
-
-type NamespaceableDynamicResourceInterface interface {
-	Namespace(string) DynamicResourceInterface
-	DynamicResourceInterface
-}
-
 type dynamicClient struct {
 	client *rest.RESTClient
 }

-var _ DynamicInterface = &dynamicClient{}
+var _ Interface = &dynamicClient{}

-func NewForConfig(inConfig *rest.Config) (DynamicInterface, error) {
+func NewForConfig(inConfig *rest.Config) (Interface, error) {
 	config := rest.CopyConfig(inConfig)
 	// for serializing the options
 	config.GroupVersion = &schema.GroupVersion{}
@@ -84,40 +57,36 @@ func NewForConfig(inConfig *rest.Config) (DynamicInterface, error) {
 }

 type dynamicResourceClient struct {
-	client      *dynamicClient
-	namespace   string
-	resource    schema.GroupVersionResource
-	subresource string
+	client    *dynamicClient
+	namespace string
+	resource  schema.GroupVersionResource
 }

-func (c *dynamicClient) Resource(resource schema.GroupVersionResource) NamespaceableDynamicResourceInterface {
+func (c *dynamicClient) Resource(resource schema.GroupVersionResource) NamespaceableResourceInterface {
 	return &dynamicResourceClient{client: c, resource: resource}
 }

-func (c *dynamicClient) ClusterSubresource(resource schema.GroupVersionResource, subresource string) DynamicResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource, subresource: subresource}
-}
-func (c *dynamicClient) NamespacedSubresource(resource schema.GroupVersionResource, subresource, namespace string) DynamicResourceInterface {
-	return &dynamicResourceClient{client: c, resource: resource, namespace: namespace, subresource: subresource}
-}
-
-func (c *dynamicResourceClient) Namespace(ns string) DynamicResourceInterface {
+func (c *dynamicResourceClient) Namespace(ns string) ResourceInterface {
 	ret := *c
 	ret.namespace = ns
 	return &ret
 }

-func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	if len(c.subresource) > 0 {
-		return nil, fmt.Errorf("create not supported for subresources")
-	}
-
+func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error) {
 	outBytes, err := runtime.Encode(unstructured.UnstructuredJSONScheme, obj)
 	if err != nil {
 		return nil, err
 	}
+	name := ""
+	if len(subresources) > 0 {
+		accessor, err := meta.Accessor(obj)
+		if err != nil {
+			return nil, err
+		}
+		name = accessor.GetName()
+	}

-	result := c.client.client.Post().AbsPath(c.makeURLSegments("")...).Body(outBytes).Do()
+	result := c.client.client.Post().AbsPath(append(c.makeURLSegments(name), subresources...)...).Body(outBytes).Do()
 	if err := result.Error(); err != nil {
 		return nil, err
 	}
@@ -133,7 +102,7 @@ func (c *dynamicResourceClient) Create(obj *unstructured.Unstructured) (*unstruc
 	return uncastObj.(*unstructured.Unstructured), nil
 }

-func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
+func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured, subresources ...string) (*unstructured.Unstructured, error) {
 	accessor, err := meta.Accessor(obj)
 	if err != nil {
 		return nil, err
@@ -143,7 +112,7 @@ func (c *dynamicResourceClient) Update(obj *unstructured.Unstructured) (*unstruc
 		return nil, err
 	}

-	result := c.client.client.Put().AbsPath(c.makeURLSegments(accessor.GetName())...).Body(outBytes).Do()
+	result := c.client.client.Put().AbsPath(append(c.makeURLSegments(accessor.GetName()), subresources...)...).Body(outBytes).Do()
 	if err := result.Error(); err != nil {
 		return nil, err
 	}
@@ -171,6 +140,10 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured) (*u
 	}

 	result := c.client.client.Put().AbsPath(append(c.makeURLSegments(accessor.GetName()), "status")...).Body(outBytes).Do()
+	if err := result.Error(); err != nil {
+		return nil, err
+	}
+
 	retBytes, err := result.Raw()
 	if err != nil {
 		return nil, err
@@ -182,7 +155,7 @@ func (c *dynamicResourceClient) UpdateStatus(obj *unstructured.Unstructured) (*u
 	return uncastObj.(*unstructured.Unstructured), nil
 }

-func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
+func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions, subresources ...string) error {
 	if opts == nil {
 		opts = &metav1.DeleteOptions{}
 	}
@@ -191,15 +164,11 @@ func (c *dynamicResourceClient) Delete(name string, opts *metav1.DeleteOptions)
 		return err
 	}

-	result := c.client.client.Delete().AbsPath(c.makeURLSegments(name)...).Body(deleteOptionsByte).Do()
+	result := c.client.client.Delete().AbsPath(append(c.makeURLSegments(name), subresources...)...).Body(deleteOptionsByte).Do()
 	return result.Error()
 }

 func (c *dynamicResourceClient) DeleteCollection(opts *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
-	if len(c.subresource) > 0 {
-		return fmt.Errorf("deletecollection not supported for subresources")
-	}
-
 	if opts == nil {
 		opts = &metav1.DeleteOptions{}
 	}
@@ -212,8 +181,8 @@ func (c *dynamicResourceClient) DeleteCollection(opts *metav1.DeleteOptions, lis
 	return result.Error()
 }

-func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions) (*unstructured.Unstructured, error) {
-	result := c.client.client.Get().AbsPath(c.makeURLSegments(name)...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do()
+func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions, subresources ...string) (*unstructured.Unstructured, error) {
+	result := c.client.client.Get().AbsPath(append(c.makeURLSegments(name), subresources...)...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do()
 	if err := result.Error(); err != nil {
 		return nil, err
 	}
@@ -229,10 +198,6 @@ func (c *dynamicResourceClient) Get(name string, opts metav1.GetOptions) (*unstr
 }

 func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.UnstructuredList, error) {
-	if len(c.subresource) > 0 {
-		return nil, fmt.Errorf("list not supported for subresources")
-	}
-
 	result := c.client.client.Get().AbsPath(c.makeURLSegments("")...).SpecificallyVersionedParams(&opts, dynamicParameterCodec, versionV1).Do()
 	if err := result.Error(); err != nil {
 		return nil, err
@@ -257,10 +222,6 @@ func (c *dynamicResourceClient) List(opts metav1.ListOptions) (*unstructured.Uns
 }

 func (c *dynamicResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
-	if len(c.subresource) > 0 {
-		return nil, fmt.Errorf("watch not supported for subresources")
-	}
-
 	internalGV := schema.GroupVersions{
 		{Group: c.resource.Group, Version: runtime.APIVersionInternal},
 		// always include the legacy group as a decoding target to handle non-error `Status` return types
@@ -320,15 +281,6 @@ func (c *dynamicResourceClient) makeURLSegments(name string) []string {

 	if len(name) > 0 {
 		url = append(url, name)
-
-		// subresources only work on things with names
-		if len(c.subresource) > 0 {
-			url = append(url, c.subresource)
-		}
-	} else {
-		if len(c.subresource) > 0 {
-			panic("somehow snuck a subresource and an empty name.  programmer error")
-		}
 	}

 	return url
--- a/informers/generic.go
+++ b/informers/generic.go
@@ -41,6 +41,7 @@ import (
 	rbac_v1alpha1 "k8s.io/api/rbac/v1alpha1"
 	rbac_v1beta1 "k8s.io/api/rbac/v1beta1"
 	scheduling_v1alpha1 "k8s.io/api/scheduling/v1alpha1"
+	scheduling_v1beta1 "k8s.io/api/scheduling/v1beta1"
 	settings_v1alpha1 "k8s.io/api/settings/v1alpha1"
 	storage_v1 "k8s.io/api/storage/v1"
 	storage_v1alpha1 "k8s.io/api/storage/v1alpha1"
@@ -235,6 +236,10 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource
 	case scheduling_v1alpha1.SchemeGroupVersion.WithResource("priorityclasses"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Scheduling().V1alpha1().PriorityClasses().Informer()}, nil

+		// Group=scheduling.k8s.io, Version=v1beta1
+	case scheduling_v1beta1.SchemeGroupVersion.WithResource("priorityclasses"):
+		return &genericInformer{resource: resource.GroupResource(), informer: f.Scheduling().V1beta1().PriorityClasses().Informer()}, nil
+
 		// Group=settings.k8s.io, Version=v1alpha1
 	case settings_v1alpha1.SchemeGroupVersion.WithResource("podpresets"):
 		return &genericInformer{resource: resource.GroupResource(), informer: f.Settings().V1alpha1().PodPresets().Informer()}, nil
--- a/informers/scheduling/interface.go
+++ b/informers/scheduling/interface.go
@@ -21,12 +21,15 @@ package scheduling
 import (
 	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
 	v1alpha1 "k8s.io/client-go/informers/scheduling/v1alpha1"
+	v1beta1 "k8s.io/client-go/informers/scheduling/v1beta1"
 )

 // Interface provides access to each of this group's versions.
 type Interface interface {
 	// V1alpha1 provides access to shared informers for resources in V1alpha1.
 	V1alpha1() v1alpha1.Interface
+	// V1beta1 provides access to shared informers for resources in V1beta1.
+	V1beta1() v1beta1.Interface
 }

 type group struct {
@@ -44,3 +47,8 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList
 func (g *group) V1alpha1() v1alpha1.Interface {
 	return v1alpha1.New(g.factory, g.namespace, g.tweakListOptions)
 }
+
+// V1beta1 returns a new v1beta1.Interface.
+func (g *group) V1beta1() v1beta1.Interface {
+	return v1beta1.New(g.factory, g.namespace, g.tweakListOptions)
+}
--- a/informers/scheduling/v1beta1/interface.go
+++ b/informers/scheduling/v1beta1/interface.go
@@ -0,0 +1,45 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+)
+
+// Interface provides access to all the informers in this group version.
+type Interface interface {
+	// PriorityClasses returns a PriorityClassInformer.
+	PriorityClasses() PriorityClassInformer
+}
+
+type version struct {
+	factory          internalinterfaces.SharedInformerFactory
+	namespace        string
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// New returns a new Interface.
+func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakListOptions internalinterfaces.TweakListOptionsFunc) Interface {
+	return &version{factory: f, namespace: namespace, tweakListOptions: tweakListOptions}
+}
+
+// PriorityClasses returns a PriorityClassInformer.
+func (v *version) PriorityClasses() PriorityClassInformer {
+	return &priorityClassInformer{factory: v.factory, tweakListOptions: v.tweakListOptions}
+}
--- a/informers/scheduling/v1beta1/priorityclass.go
+++ b/informers/scheduling/v1beta1/priorityclass.go
@@ -0,0 +1,88 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by informer-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	time "time"
+
+	scheduling_v1beta1 "k8s.io/api/scheduling/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+	watch "k8s.io/apimachinery/pkg/watch"
+	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
+	kubernetes "k8s.io/client-go/kubernetes"
+	v1beta1 "k8s.io/client-go/listers/scheduling/v1beta1"
+	cache "k8s.io/client-go/tools/cache"
+)
+
+// PriorityClassInformer provides access to a shared informer and lister for
+// PriorityClasses.
+type PriorityClassInformer interface {
+	Informer() cache.SharedIndexInformer
+	Lister() v1beta1.PriorityClassLister
+}
+
+type priorityClassInformer struct {
+	factory          internalinterfaces.SharedInformerFactory
+	tweakListOptions internalinterfaces.TweakListOptionsFunc
+}
+
+// NewPriorityClassInformer constructs a new informer for PriorityClass type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewPriorityClassInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer {
+	return NewFilteredPriorityClassInformer(client, resyncPeriod, indexers, nil)
+}
+
+// NewFilteredPriorityClassInformer constructs a new informer for PriorityClass type.
+// Always prefer using an informer factory to get a shared informer instead of getting an independent
+// one. This reduces memory footprint and number of connections to the server.
+func NewFilteredPriorityClassInformer(client kubernetes.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer {
+	return cache.NewSharedIndexInformer(
+		&cache.ListWatch{
+			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.SchedulingV1beta1().PriorityClasses().List(options)
+			},
+			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
+				if tweakListOptions != nil {
+					tweakListOptions(&options)
+				}
+				return client.SchedulingV1beta1().PriorityClasses().Watch(options)
+			},
+		},
+		&scheduling_v1beta1.PriorityClass{},
+		resyncPeriod,
+		indexers,
+	)
+}
+
+func (f *priorityClassInformer) defaultInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
+	return NewFilteredPriorityClassInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions)
+}
+
+func (f *priorityClassInformer) Informer() cache.SharedIndexInformer {
+	return f.factory.InformerFor(&scheduling_v1beta1.PriorityClass{}, f.defaultInformer)
+}
+
+func (f *priorityClassInformer) Lister() v1beta1.PriorityClassLister {
+	return v1beta1.NewPriorityClassLister(f.Informer().GetIndexer())
+}
--- a/kubernetes/clientset.go
+++ b/kubernetes/clientset.go
@@ -44,6 +44,7 @@ import (
 	rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
 	rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
 	schedulingv1alpha1 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
+	schedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
 	settingsv1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1"
 	storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1"
 	storagev1alpha1 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
@@ -104,8 +105,9 @@ type Interface interface {
 	RbacV1beta1() rbacv1beta1.RbacV1beta1Interface
 	RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface
 	SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1Interface
+	SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface
+	Scheduling() schedulingv1beta1.SchedulingV1beta1Interface
 	SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface
 	// Deprecated: please explicitly pick a version if possible.
 	Settings() settingsv1alpha1.SettingsV1alpha1Interface
@@ -144,6 +146,7 @@ type Clientset struct {
 	rbacV1beta1                   *rbacv1beta1.RbacV1beta1Client
 	rbacV1alpha1                  *rbacv1alpha1.RbacV1alpha1Client
 	schedulingV1alpha1            *schedulingv1alpha1.SchedulingV1alpha1Client
+	schedulingV1beta1             *schedulingv1beta1.SchedulingV1beta1Client
 	settingsV1alpha1              *settingsv1alpha1.SettingsV1alpha1Client
 	storageV1beta1                *storagev1beta1.StorageV1beta1Client
 	storageV1                     *storagev1.StorageV1Client
@@ -348,10 +351,15 @@ func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1In
 	return c.schedulingV1alpha1
 }

+// SchedulingV1beta1 retrieves the SchedulingV1beta1Client
+func (c *Clientset) SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface {
+	return c.schedulingV1beta1
+}
+
 // Deprecated: Scheduling retrieves the default version of SchedulingClient.
 // Please explicitly pick a version.
-func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface {
-	return c.schedulingV1alpha1
+func (c *Clientset) Scheduling() schedulingv1beta1.SchedulingV1beta1Interface {
+	return c.schedulingV1beta1
 }

 // SettingsV1alpha1 retrieves the SettingsV1alpha1Client
@@ -498,6 +506,10 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if err != nil {
 		return nil, err
 	}
+	cs.schedulingV1beta1, err = schedulingv1beta1.NewForConfig(&configShallowCopy)
+	if err != nil {
+		return nil, err
+	}
 	cs.settingsV1alpha1, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
@@ -550,6 +562,7 @@ func NewForConfigOrDie(c *rest.Config) *Clientset {
 	cs.rbacV1beta1 = rbacv1beta1.NewForConfigOrDie(c)
 	cs.rbacV1alpha1 = rbacv1alpha1.NewForConfigOrDie(c)
 	cs.schedulingV1alpha1 = schedulingv1alpha1.NewForConfigOrDie(c)
+	cs.schedulingV1beta1 = schedulingv1beta1.NewForConfigOrDie(c)
 	cs.settingsV1alpha1 = settingsv1alpha1.NewForConfigOrDie(c)
 	cs.storageV1beta1 = storagev1beta1.NewForConfigOrDie(c)
 	cs.storageV1 = storagev1.NewForConfigOrDie(c)
@@ -586,6 +599,7 @@ func New(c rest.Interface) *Clientset {
 	cs.rbacV1beta1 = rbacv1beta1.New(c)
 	cs.rbacV1alpha1 = rbacv1alpha1.New(c)
 	cs.schedulingV1alpha1 = schedulingv1alpha1.New(c)
+	cs.schedulingV1beta1 = schedulingv1beta1.New(c)
 	cs.settingsV1alpha1 = settingsv1alpha1.New(c)
 	cs.storageV1beta1 = storagev1beta1.New(c)
 	cs.storageV1 = storagev1.New(c)
--- a/kubernetes/fake/clientset_generated.go
+++ b/kubernetes/fake/clientset_generated.go
@@ -72,6 +72,8 @@ import (
 	fakerbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1/fake"
 	schedulingv1alpha1 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
 	fakeschedulingv1alpha1 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1/fake"
+	schedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
+	fakeschedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1/fake"
 	settingsv1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1"
 	fakesettingsv1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1/fake"
 	storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1"
@@ -310,9 +312,14 @@ func (c *Clientset) SchedulingV1alpha1() schedulingv1alpha1.SchedulingV1alpha1In
 	return &fakeschedulingv1alpha1.FakeSchedulingV1alpha1{Fake: &c.Fake}
 }

-// Scheduling retrieves the SchedulingV1alpha1Client
-func (c *Clientset) Scheduling() schedulingv1alpha1.SchedulingV1alpha1Interface {
-	return &fakeschedulingv1alpha1.FakeSchedulingV1alpha1{Fake: &c.Fake}
+// SchedulingV1beta1 retrieves the SchedulingV1beta1Client
+func (c *Clientset) SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Interface {
+	return &fakeschedulingv1beta1.FakeSchedulingV1beta1{Fake: &c.Fake}
+}
+
+// Scheduling retrieves the SchedulingV1beta1Client
+func (c *Clientset) Scheduling() schedulingv1beta1.SchedulingV1beta1Interface {
+	return &fakeschedulingv1beta1.FakeSchedulingV1beta1{Fake: &c.Fake}
 }

 // SettingsV1alpha1 retrieves the SettingsV1alpha1Client
--- a/kubernetes/fake/register.go
+++ b/kubernetes/fake/register.go
@@ -43,6 +43,7 @@ import (
 	rbacv1alpha1 "k8s.io/api/rbac/v1alpha1"
 	rbacv1beta1 "k8s.io/api/rbac/v1beta1"
 	schedulingv1alpha1 "k8s.io/api/scheduling/v1alpha1"
+	schedulingv1beta1 "k8s.io/api/scheduling/v1beta1"
 	settingsv1alpha1 "k8s.io/api/settings/v1alpha1"
 	storagev1 "k8s.io/api/storage/v1"
 	storagev1alpha1 "k8s.io/api/storage/v1alpha1"
@@ -101,6 +102,7 @@ func AddToScheme(scheme *runtime.Scheme) {
 	rbacv1beta1.AddToScheme(scheme)
 	rbacv1alpha1.AddToScheme(scheme)
 	schedulingv1alpha1.AddToScheme(scheme)
+	schedulingv1beta1.AddToScheme(scheme)
 	settingsv1alpha1.AddToScheme(scheme)
 	storagev1beta1.AddToScheme(scheme)
 	storagev1.AddToScheme(scheme)
--- a/kubernetes/scheme/register.go
+++ b/kubernetes/scheme/register.go
@@ -43,6 +43,7 @@ import (
 	rbacv1alpha1 "k8s.io/api/rbac/v1alpha1"
 	rbacv1beta1 "k8s.io/api/rbac/v1beta1"
 	schedulingv1alpha1 "k8s.io/api/scheduling/v1alpha1"
+	schedulingv1beta1 "k8s.io/api/scheduling/v1beta1"
 	settingsv1alpha1 "k8s.io/api/settings/v1alpha1"
 	storagev1 "k8s.io/api/storage/v1"
 	storagev1alpha1 "k8s.io/api/storage/v1alpha1"
@@ -101,6 +102,7 @@ func AddToScheme(scheme *runtime.Scheme) {
 	rbacv1beta1.AddToScheme(scheme)
 	rbacv1alpha1.AddToScheme(scheme)
 	schedulingv1alpha1.AddToScheme(scheme)
+	schedulingv1beta1.AddToScheme(scheme)
 	settingsv1alpha1.AddToScheme(scheme)
 	storagev1beta1.AddToScheme(scheme)
 	storagev1.AddToScheme(scheme)
--- a/kubernetes/typed/admissionregistration/v1alpha1/fake/fake_initializerconfiguration.go
+++ b/kubernetes/typed/admissionregistration/v1alpha1/fake/fake_initializerconfiguration.go
@@ -59,7 +59,7 @@ func (c *FakeInitializerConfigurations) List(opts v1.ListOptions) (result *v1alp
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.InitializerConfigurationList{}
+	list := &v1alpha1.InitializerConfigurationList{ListMeta: obj.(*v1alpha1.InitializerConfigurationList).ListMeta}
 	for _, item := range obj.(*v1alpha1.InitializerConfigurationList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/admissionregistration/v1beta1/fake/fake_mutatingwebhookconfiguration.go
+++ b/kubernetes/typed/admissionregistration/v1beta1/fake/fake_mutatingwebhookconfiguration.go
@@ -59,7 +59,7 @@ func (c *FakeMutatingWebhookConfigurations) List(opts v1.ListOptions) (result *v
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.MutatingWebhookConfigurationList{}
+	list := &v1beta1.MutatingWebhookConfigurationList{ListMeta: obj.(*v1beta1.MutatingWebhookConfigurationList).ListMeta}
 	for _, item := range obj.(*v1beta1.MutatingWebhookConfigurationList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/admissionregistration/v1beta1/fake/fake_validatingwebhookconfiguration.go
+++ b/kubernetes/typed/admissionregistration/v1beta1/fake/fake_validatingwebhookconfiguration.go
@@ -59,7 +59,7 @@ func (c *FakeValidatingWebhookConfigurations) List(opts v1.ListOptions) (result
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.ValidatingWebhookConfigurationList{}
+	list := &v1beta1.ValidatingWebhookConfigurationList{ListMeta: obj.(*v1beta1.ValidatingWebhookConfigurationList).ListMeta}
 	for _, item := range obj.(*v1beta1.ValidatingWebhookConfigurationList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1/fake/fake_controllerrevision.go
+++ b/kubernetes/typed/apps/v1/fake/fake_controllerrevision.go
@@ -62,7 +62,7 @@ func (c *FakeControllerRevisions) List(opts v1.ListOptions) (result *apps_v1.Con
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &apps_v1.ControllerRevisionList{}
+	list := &apps_v1.ControllerRevisionList{ListMeta: obj.(*apps_v1.ControllerRevisionList).ListMeta}
 	for _, item := range obj.(*apps_v1.ControllerRevisionList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1/fake/fake_daemonset.go
+++ b/kubernetes/typed/apps/v1/fake/fake_daemonset.go
@@ -62,7 +62,7 @@ func (c *FakeDaemonSets) List(opts v1.ListOptions) (result *apps_v1.DaemonSetLis
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &apps_v1.DaemonSetList{}
+	list := &apps_v1.DaemonSetList{ListMeta: obj.(*apps_v1.DaemonSetList).ListMeta}
 	for _, item := range obj.(*apps_v1.DaemonSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1/fake/fake_deployment.go
+++ b/kubernetes/typed/apps/v1/fake/fake_deployment.go
@@ -62,7 +62,7 @@ func (c *FakeDeployments) List(opts v1.ListOptions) (result *apps_v1.DeploymentL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &apps_v1.DeploymentList{}
+	list := &apps_v1.DeploymentList{ListMeta: obj.(*apps_v1.DeploymentList).ListMeta}
 	for _, item := range obj.(*apps_v1.DeploymentList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1/fake/fake_replicaset.go
+++ b/kubernetes/typed/apps/v1/fake/fake_replicaset.go
@@ -62,7 +62,7 @@ func (c *FakeReplicaSets) List(opts v1.ListOptions) (result *apps_v1.ReplicaSetL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &apps_v1.ReplicaSetList{}
+	list := &apps_v1.ReplicaSetList{ListMeta: obj.(*apps_v1.ReplicaSetList).ListMeta}
 	for _, item := range obj.(*apps_v1.ReplicaSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1/fake/fake_statefulset.go
+++ b/kubernetes/typed/apps/v1/fake/fake_statefulset.go
@@ -62,7 +62,7 @@ func (c *FakeStatefulSets) List(opts v1.ListOptions) (result *apps_v1.StatefulSe
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &apps_v1.StatefulSetList{}
+	list := &apps_v1.StatefulSetList{ListMeta: obj.(*apps_v1.StatefulSetList).ListMeta}
 	for _, item := range obj.(*apps_v1.StatefulSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta1/fake/fake_controllerrevision.go
+++ b/kubernetes/typed/apps/v1beta1/fake/fake_controllerrevision.go
@@ -62,7 +62,7 @@ func (c *FakeControllerRevisions) List(opts v1.ListOptions) (result *v1beta1.Con
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.ControllerRevisionList{}
+	list := &v1beta1.ControllerRevisionList{ListMeta: obj.(*v1beta1.ControllerRevisionList).ListMeta}
 	for _, item := range obj.(*v1beta1.ControllerRevisionList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta1/fake/fake_deployment.go
+++ b/kubernetes/typed/apps/v1beta1/fake/fake_deployment.go
@@ -62,7 +62,7 @@ func (c *FakeDeployments) List(opts v1.ListOptions) (result *v1beta1.DeploymentL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.DeploymentList{}
+	list := &v1beta1.DeploymentList{ListMeta: obj.(*v1beta1.DeploymentList).ListMeta}
 	for _, item := range obj.(*v1beta1.DeploymentList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta1/fake/fake_statefulset.go
+++ b/kubernetes/typed/apps/v1beta1/fake/fake_statefulset.go
@@ -62,7 +62,7 @@ func (c *FakeStatefulSets) List(opts v1.ListOptions) (result *v1beta1.StatefulSe
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.StatefulSetList{}
+	list := &v1beta1.StatefulSetList{ListMeta: obj.(*v1beta1.StatefulSetList).ListMeta}
 	for _, item := range obj.(*v1beta1.StatefulSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta2/fake/fake_controllerrevision.go
+++ b/kubernetes/typed/apps/v1beta2/fake/fake_controllerrevision.go
@@ -62,7 +62,7 @@ func (c *FakeControllerRevisions) List(opts v1.ListOptions) (result *v1beta2.Con
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta2.ControllerRevisionList{}
+	list := &v1beta2.ControllerRevisionList{ListMeta: obj.(*v1beta2.ControllerRevisionList).ListMeta}
 	for _, item := range obj.(*v1beta2.ControllerRevisionList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta2/fake/fake_daemonset.go
+++ b/kubernetes/typed/apps/v1beta2/fake/fake_daemonset.go
@@ -62,7 +62,7 @@ func (c *FakeDaemonSets) List(opts v1.ListOptions) (result *v1beta2.DaemonSetLis
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta2.DaemonSetList{}
+	list := &v1beta2.DaemonSetList{ListMeta: obj.(*v1beta2.DaemonSetList).ListMeta}
 	for _, item := range obj.(*v1beta2.DaemonSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta2/fake/fake_deployment.go
+++ b/kubernetes/typed/apps/v1beta2/fake/fake_deployment.go
@@ -62,7 +62,7 @@ func (c *FakeDeployments) List(opts v1.ListOptions) (result *v1beta2.DeploymentL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta2.DeploymentList{}
+	list := &v1beta2.DeploymentList{ListMeta: obj.(*v1beta2.DeploymentList).ListMeta}
 	for _, item := range obj.(*v1beta2.DeploymentList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta2/fake/fake_replicaset.go
+++ b/kubernetes/typed/apps/v1beta2/fake/fake_replicaset.go
@@ -62,7 +62,7 @@ func (c *FakeReplicaSets) List(opts v1.ListOptions) (result *v1beta2.ReplicaSetL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta2.ReplicaSetList{}
+	list := &v1beta2.ReplicaSetList{ListMeta: obj.(*v1beta2.ReplicaSetList).ListMeta}
 	for _, item := range obj.(*v1beta2.ReplicaSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/apps/v1beta2/fake/fake_statefulset.go
+++ b/kubernetes/typed/apps/v1beta2/fake/fake_statefulset.go
@@ -62,7 +62,7 @@ func (c *FakeStatefulSets) List(opts v1.ListOptions) (result *v1beta2.StatefulSe
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta2.StatefulSetList{}
+	list := &v1beta2.StatefulSetList{ListMeta: obj.(*v1beta2.StatefulSetList).ListMeta}
 	for _, item := range obj.(*v1beta2.StatefulSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/autoscaling/v1/fake/fake_horizontalpodautoscaler.go
+++ b/kubernetes/typed/autoscaling/v1/fake/fake_horizontalpodautoscaler.go
@@ -62,7 +62,7 @@ func (c *FakeHorizontalPodAutoscalers) List(opts v1.ListOptions) (result *autosc
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &autoscaling_v1.HorizontalPodAutoscalerList{}
+	list := &autoscaling_v1.HorizontalPodAutoscalerList{ListMeta: obj.(*autoscaling_v1.HorizontalPodAutoscalerList).ListMeta}
 	for _, item := range obj.(*autoscaling_v1.HorizontalPodAutoscalerList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/autoscaling/v2beta1/fake/fake_horizontalpodautoscaler.go
+++ b/kubernetes/typed/autoscaling/v2beta1/fake/fake_horizontalpodautoscaler.go
@@ -62,7 +62,7 @@ func (c *FakeHorizontalPodAutoscalers) List(opts v1.ListOptions) (result *v2beta
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v2beta1.HorizontalPodAutoscalerList{}
+	list := &v2beta1.HorizontalPodAutoscalerList{ListMeta: obj.(*v2beta1.HorizontalPodAutoscalerList).ListMeta}
 	for _, item := range obj.(*v2beta1.HorizontalPodAutoscalerList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/batch/v1/fake/fake_job.go
+++ b/kubernetes/typed/batch/v1/fake/fake_job.go
@@ -62,7 +62,7 @@ func (c *FakeJobs) List(opts v1.ListOptions) (result *batch_v1.JobList, err erro
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &batch_v1.JobList{}
+	list := &batch_v1.JobList{ListMeta: obj.(*batch_v1.JobList).ListMeta}
 	for _, item := range obj.(*batch_v1.JobList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/batch/v1beta1/fake/fake_cronjob.go
+++ b/kubernetes/typed/batch/v1beta1/fake/fake_cronjob.go
@@ -62,7 +62,7 @@ func (c *FakeCronJobs) List(opts v1.ListOptions) (result *v1beta1.CronJobList, e
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.CronJobList{}
+	list := &v1beta1.CronJobList{ListMeta: obj.(*v1beta1.CronJobList).ListMeta}
 	for _, item := range obj.(*v1beta1.CronJobList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/batch/v2alpha1/fake/fake_cronjob.go
+++ b/kubernetes/typed/batch/v2alpha1/fake/fake_cronjob.go
@@ -62,7 +62,7 @@ func (c *FakeCronJobs) List(opts v1.ListOptions) (result *v2alpha1.CronJobList,
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v2alpha1.CronJobList{}
+	list := &v2alpha1.CronJobList{ListMeta: obj.(*v2alpha1.CronJobList).ListMeta}
 	for _, item := range obj.(*v2alpha1.CronJobList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/certificates/v1beta1/fake/fake_certificatesigningrequest.go
+++ b/kubernetes/typed/certificates/v1beta1/fake/fake_certificatesigningrequest.go
@@ -59,7 +59,7 @@ func (c *FakeCertificateSigningRequests) List(opts v1.ListOptions) (result *v1be
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.CertificateSigningRequestList{}
+	list := &v1beta1.CertificateSigningRequestList{ListMeta: obj.(*v1beta1.CertificateSigningRequestList).ListMeta}
 	for _, item := range obj.(*v1beta1.CertificateSigningRequestList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_componentstatus.go
+++ b/kubernetes/typed/core/v1/fake/fake_componentstatus.go
@@ -59,7 +59,7 @@ func (c *FakeComponentStatuses) List(opts v1.ListOptions) (result *core_v1.Compo
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ComponentStatusList{}
+	list := &core_v1.ComponentStatusList{ListMeta: obj.(*core_v1.ComponentStatusList).ListMeta}
 	for _, item := range obj.(*core_v1.ComponentStatusList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_configmap.go
+++ b/kubernetes/typed/core/v1/fake/fake_configmap.go
@@ -62,7 +62,7 @@ func (c *FakeConfigMaps) List(opts v1.ListOptions) (result *core_v1.ConfigMapLis
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ConfigMapList{}
+	list := &core_v1.ConfigMapList{ListMeta: obj.(*core_v1.ConfigMapList).ListMeta}
 	for _, item := range obj.(*core_v1.ConfigMapList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_endpoints.go
+++ b/kubernetes/typed/core/v1/fake/fake_endpoints.go
@@ -62,7 +62,7 @@ func (c *FakeEndpoints) List(opts v1.ListOptions) (result *core_v1.EndpointsList
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.EndpointsList{}
+	list := &core_v1.EndpointsList{ListMeta: obj.(*core_v1.EndpointsList).ListMeta}
 	for _, item := range obj.(*core_v1.EndpointsList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_event.go
+++ b/kubernetes/typed/core/v1/fake/fake_event.go
@@ -62,7 +62,7 @@ func (c *FakeEvents) List(opts v1.ListOptions) (result *core_v1.EventList, err e
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.EventList{}
+	list := &core_v1.EventList{ListMeta: obj.(*core_v1.EventList).ListMeta}
 	for _, item := range obj.(*core_v1.EventList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_limitrange.go
+++ b/kubernetes/typed/core/v1/fake/fake_limitrange.go
@@ -62,7 +62,7 @@ func (c *FakeLimitRanges) List(opts v1.ListOptions) (result *core_v1.LimitRangeL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.LimitRangeList{}
+	list := &core_v1.LimitRangeList{ListMeta: obj.(*core_v1.LimitRangeList).ListMeta}
 	for _, item := range obj.(*core_v1.LimitRangeList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_namespace.go
+++ b/kubernetes/typed/core/v1/fake/fake_namespace.go
@@ -59,7 +59,7 @@ func (c *FakeNamespaces) List(opts v1.ListOptions) (result *core_v1.NamespaceLis
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.NamespaceList{}
+	list := &core_v1.NamespaceList{ListMeta: obj.(*core_v1.NamespaceList).ListMeta}
 	for _, item := range obj.(*core_v1.NamespaceList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
@@ -112,14 +112,6 @@ func (c *FakeNamespaces) Delete(name string, options *v1.DeleteOptions) error {
 	return err
 }

-// DeleteCollection deletes a collection of objects.
-func (c *FakeNamespaces) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewRootDeleteCollectionAction(namespacesResource, listOptions)
-
-	_, err := c.Fake.Invokes(action, &core_v1.NamespaceList{})
-	return err
-}
-
 // Patch applies the patch and returns the patched namespace.
 func (c *FakeNamespaces) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *core_v1.Namespace, err error) {
 	obj, err := c.Fake.
--- a/kubernetes/typed/core/v1/fake/fake_node.go
+++ b/kubernetes/typed/core/v1/fake/fake_node.go
@@ -59,7 +59,7 @@ func (c *FakeNodes) List(opts v1.ListOptions) (result *core_v1.NodeList, err err
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.NodeList{}
+	list := &core_v1.NodeList{ListMeta: obj.(*core_v1.NodeList).ListMeta}
 	for _, item := range obj.(*core_v1.NodeList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_persistentvolume.go
+++ b/kubernetes/typed/core/v1/fake/fake_persistentvolume.go
@@ -59,7 +59,7 @@ func (c *FakePersistentVolumes) List(opts v1.ListOptions) (result *core_v1.Persi
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.PersistentVolumeList{}
+	list := &core_v1.PersistentVolumeList{ListMeta: obj.(*core_v1.PersistentVolumeList).ListMeta}
 	for _, item := range obj.(*core_v1.PersistentVolumeList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_persistentvolumeclaim.go
+++ b/kubernetes/typed/core/v1/fake/fake_persistentvolumeclaim.go
@@ -62,7 +62,7 @@ func (c *FakePersistentVolumeClaims) List(opts v1.ListOptions) (result *core_v1.
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.PersistentVolumeClaimList{}
+	list := &core_v1.PersistentVolumeClaimList{ListMeta: obj.(*core_v1.PersistentVolumeClaimList).ListMeta}
 	for _, item := range obj.(*core_v1.PersistentVolumeClaimList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_pod.go
+++ b/kubernetes/typed/core/v1/fake/fake_pod.go
@@ -62,7 +62,7 @@ func (c *FakePods) List(opts v1.ListOptions) (result *core_v1.PodList, err error
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.PodList{}
+	list := &core_v1.PodList{ListMeta: obj.(*core_v1.PodList).ListMeta}
 	for _, item := range obj.(*core_v1.PodList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_podtemplate.go
+++ b/kubernetes/typed/core/v1/fake/fake_podtemplate.go
@@ -62,7 +62,7 @@ func (c *FakePodTemplates) List(opts v1.ListOptions) (result *core_v1.PodTemplat
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.PodTemplateList{}
+	list := &core_v1.PodTemplateList{ListMeta: obj.(*core_v1.PodTemplateList).ListMeta}
 	for _, item := range obj.(*core_v1.PodTemplateList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_replicationcontroller.go
+++ b/kubernetes/typed/core/v1/fake/fake_replicationcontroller.go
@@ -63,7 +63,7 @@ func (c *FakeReplicationControllers) List(opts v1.ListOptions) (result *core_v1.
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ReplicationControllerList{}
+	list := &core_v1.ReplicationControllerList{ListMeta: obj.(*core_v1.ReplicationControllerList).ListMeta}
 	for _, item := range obj.(*core_v1.ReplicationControllerList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_resourcequota.go
+++ b/kubernetes/typed/core/v1/fake/fake_resourcequota.go
@@ -62,7 +62,7 @@ func (c *FakeResourceQuotas) List(opts v1.ListOptions) (result *core_v1.Resource
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ResourceQuotaList{}
+	list := &core_v1.ResourceQuotaList{ListMeta: obj.(*core_v1.ResourceQuotaList).ListMeta}
 	for _, item := range obj.(*core_v1.ResourceQuotaList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_secret.go
+++ b/kubernetes/typed/core/v1/fake/fake_secret.go
@@ -62,7 +62,7 @@ func (c *FakeSecrets) List(opts v1.ListOptions) (result *core_v1.SecretList, err
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.SecretList{}
+	list := &core_v1.SecretList{ListMeta: obj.(*core_v1.SecretList).ListMeta}
 	for _, item := range obj.(*core_v1.SecretList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/fake/fake_service.go
+++ b/kubernetes/typed/core/v1/fake/fake_service.go
@@ -62,7 +62,7 @@ func (c *FakeServices) List(opts v1.ListOptions) (result *core_v1.ServiceList, e
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ServiceList{}
+	list := &core_v1.ServiceList{ListMeta: obj.(*core_v1.ServiceList).ListMeta}
 	for _, item := range obj.(*core_v1.ServiceList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
@@ -120,14 +120,6 @@ func (c *FakeServices) Delete(name string, options *v1.DeleteOptions) error {
 	return err
 }

-// DeleteCollection deletes a collection of objects.
-func (c *FakeServices) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
-	action := testing.NewDeleteCollectionAction(servicesResource, c.ns, listOptions)
-
-	_, err := c.Fake.Invokes(action, &core_v1.ServiceList{})
-	return err
-}
-
 // Patch applies the patch and returns the patched service.
 func (c *FakeServices) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *core_v1.Service, err error) {
 	obj, err := c.Fake.
--- a/kubernetes/typed/core/v1/fake/fake_serviceaccount.go
+++ b/kubernetes/typed/core/v1/fake/fake_serviceaccount.go
@@ -62,7 +62,7 @@ func (c *FakeServiceAccounts) List(opts v1.ListOptions) (result *core_v1.Service
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &core_v1.ServiceAccountList{}
+	list := &core_v1.ServiceAccountList{ListMeta: obj.(*core_v1.ServiceAccountList).ListMeta}
 	for _, item := range obj.(*core_v1.ServiceAccountList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/core/v1/namespace.go
+++ b/kubernetes/typed/core/v1/namespace.go
@@ -39,7 +39,6 @@ type NamespaceInterface interface {
 	Update(*v1.Namespace) (*v1.Namespace, error)
 	UpdateStatus(*v1.Namespace) (*v1.Namespace, error)
 	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
 	Get(name string, options meta_v1.GetOptions) (*v1.Namespace, error)
 	List(opts meta_v1.ListOptions) (*v1.NamespaceList, error)
 	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
@@ -139,16 +138,6 @@ func (c *namespaces) Delete(name string, options *meta_v1.DeleteOptions) error {
 		Error()
 }

-// DeleteCollection deletes a collection of objects.
-func (c *namespaces) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
-	return c.client.Delete().
-		Resource("namespaces").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Body(options).
-		Do().
-		Error()
-}
-
 // Patch applies the patch and returns the patched namespace.
 func (c *namespaces) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Namespace, err error) {
 	result = &v1.Namespace{}
--- a/kubernetes/typed/core/v1/service.go
+++ b/kubernetes/typed/core/v1/service.go
@@ -39,7 +39,6 @@ type ServiceInterface interface {
 	Update(*v1.Service) (*v1.Service, error)
 	UpdateStatus(*v1.Service) (*v1.Service, error)
 	Delete(name string, options *meta_v1.DeleteOptions) error
-	DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error
 	Get(name string, options meta_v1.GetOptions) (*v1.Service, error)
 	List(opts meta_v1.ListOptions) (*v1.ServiceList, error)
 	Watch(opts meta_v1.ListOptions) (watch.Interface, error)
@@ -148,17 +147,6 @@ func (c *services) Delete(name string, options *meta_v1.DeleteOptions) error {
 		Error()
 }

-// DeleteCollection deletes a collection of objects.
-func (c *services) DeleteCollection(options *meta_v1.DeleteOptions, listOptions meta_v1.ListOptions) error {
-	return c.client.Delete().
-		Namespace(c.ns).
-		Resource("services").
-		VersionedParams(&listOptions, scheme.ParameterCodec).
-		Body(options).
-		Do().
-		Error()
-}
-
 // Patch applies the patch and returns the patched service.
 func (c *services) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1.Service, err error) {
 	result = &v1.Service{}
--- a/kubernetes/typed/events/v1beta1/fake/fake_event.go
+++ b/kubernetes/typed/events/v1beta1/fake/fake_event.go
@@ -62,7 +62,7 @@ func (c *FakeEvents) List(opts v1.ListOptions) (result *v1beta1.EventList, err e
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.EventList{}
+	list := &v1beta1.EventList{ListMeta: obj.(*v1beta1.EventList).ListMeta}
 	for _, item := range obj.(*v1beta1.EventList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_daemonset.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_daemonset.go
@@ -62,7 +62,7 @@ func (c *FakeDaemonSets) List(opts v1.ListOptions) (result *v1beta1.DaemonSetLis
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.DaemonSetList{}
+	list := &v1beta1.DaemonSetList{ListMeta: obj.(*v1beta1.DaemonSetList).ListMeta}
 	for _, item := range obj.(*v1beta1.DaemonSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_deployment.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_deployment.go
@@ -62,7 +62,7 @@ func (c *FakeDeployments) List(opts v1.ListOptions) (result *v1beta1.DeploymentL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.DeploymentList{}
+	list := &v1beta1.DeploymentList{ListMeta: obj.(*v1beta1.DeploymentList).ListMeta}
 	for _, item := range obj.(*v1beta1.DeploymentList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_ingress.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_ingress.go
@@ -62,7 +62,7 @@ func (c *FakeIngresses) List(opts v1.ListOptions) (result *v1beta1.IngressList,
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.IngressList{}
+	list := &v1beta1.IngressList{ListMeta: obj.(*v1beta1.IngressList).ListMeta}
 	for _, item := range obj.(*v1beta1.IngressList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_podsecuritypolicy.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_podsecuritypolicy.go
@@ -59,7 +59,7 @@ func (c *FakePodSecurityPolicies) List(opts v1.ListOptions) (result *v1beta1.Pod
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.PodSecurityPolicyList{}
+	list := &v1beta1.PodSecurityPolicyList{ListMeta: obj.(*v1beta1.PodSecurityPolicyList).ListMeta}
 	for _, item := range obj.(*v1beta1.PodSecurityPolicyList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/extensions/v1beta1/fake/fake_replicaset.go
+++ b/kubernetes/typed/extensions/v1beta1/fake/fake_replicaset.go
@@ -62,7 +62,7 @@ func (c *FakeReplicaSets) List(opts v1.ListOptions) (result *v1beta1.ReplicaSetL
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.ReplicaSetList{}
+	list := &v1beta1.ReplicaSetList{ListMeta: obj.(*v1beta1.ReplicaSetList).ListMeta}
 	for _, item := range obj.(*v1beta1.ReplicaSetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/networking/v1/fake/fake_networkpolicy.go
+++ b/kubernetes/typed/networking/v1/fake/fake_networkpolicy.go
@@ -62,7 +62,7 @@ func (c *FakeNetworkPolicies) List(opts v1.ListOptions) (result *networking_v1.N
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &networking_v1.NetworkPolicyList{}
+	list := &networking_v1.NetworkPolicyList{ListMeta: obj.(*networking_v1.NetworkPolicyList).ListMeta}
 	for _, item := range obj.(*networking_v1.NetworkPolicyList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/policy/v1beta1/fake/fake_poddisruptionbudget.go
+++ b/kubernetes/typed/policy/v1beta1/fake/fake_poddisruptionbudget.go
@@ -62,7 +62,7 @@ func (c *FakePodDisruptionBudgets) List(opts v1.ListOptions) (result *v1beta1.Po
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.PodDisruptionBudgetList{}
+	list := &v1beta1.PodDisruptionBudgetList{ListMeta: obj.(*v1beta1.PodDisruptionBudgetList).ListMeta}
 	for _, item := range obj.(*v1beta1.PodDisruptionBudgetList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/policy/v1beta1/fake/fake_podsecuritypolicy.go
+++ b/kubernetes/typed/policy/v1beta1/fake/fake_podsecuritypolicy.go
@@ -59,7 +59,7 @@ func (c *FakePodSecurityPolicies) List(opts v1.ListOptions) (result *v1beta1.Pod
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.PodSecurityPolicyList{}
+	list := &v1beta1.PodSecurityPolicyList{ListMeta: obj.(*v1beta1.PodSecurityPolicyList).ListMeta}
 	for _, item := range obj.(*v1beta1.PodSecurityPolicyList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1/fake/fake_clusterrole.go
+++ b/kubernetes/typed/rbac/v1/fake/fake_clusterrole.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoles) List(opts v1.ListOptions) (result *rbac_v1.ClusterRol
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &rbac_v1.ClusterRoleList{}
+	list := &rbac_v1.ClusterRoleList{ListMeta: obj.(*rbac_v1.ClusterRoleList).ListMeta}
 	for _, item := range obj.(*rbac_v1.ClusterRoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1/fake/fake_clusterrolebinding.go
+++ b/kubernetes/typed/rbac/v1/fake/fake_clusterrolebinding.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoleBindings) List(opts v1.ListOptions) (result *rbac_v1.Clu
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &rbac_v1.ClusterRoleBindingList{}
+	list := &rbac_v1.ClusterRoleBindingList{ListMeta: obj.(*rbac_v1.ClusterRoleBindingList).ListMeta}
 	for _, item := range obj.(*rbac_v1.ClusterRoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1/fake/fake_role.go
+++ b/kubernetes/typed/rbac/v1/fake/fake_role.go
@@ -62,7 +62,7 @@ func (c *FakeRoles) List(opts v1.ListOptions) (result *rbac_v1.RoleList, err err
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &rbac_v1.RoleList{}
+	list := &rbac_v1.RoleList{ListMeta: obj.(*rbac_v1.RoleList).ListMeta}
 	for _, item := range obj.(*rbac_v1.RoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1/fake/fake_rolebinding.go
+++ b/kubernetes/typed/rbac/v1/fake/fake_rolebinding.go
@@ -62,7 +62,7 @@ func (c *FakeRoleBindings) List(opts v1.ListOptions) (result *rbac_v1.RoleBindin
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &rbac_v1.RoleBindingList{}
+	list := &rbac_v1.RoleBindingList{ListMeta: obj.(*rbac_v1.RoleBindingList).ListMeta}
 	for _, item := range obj.(*rbac_v1.RoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrole.go
+++ b/kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrole.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoles) List(opts v1.ListOptions) (result *v1alpha1.ClusterRo
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.ClusterRoleList{}
+	list := &v1alpha1.ClusterRoleList{ListMeta: obj.(*v1alpha1.ClusterRoleList).ListMeta}
 	for _, item := range obj.(*v1alpha1.ClusterRoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrolebinding.go
+++ b/kubernetes/typed/rbac/v1alpha1/fake/fake_clusterrolebinding.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoleBindings) List(opts v1.ListOptions) (result *v1alpha1.Cl
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.ClusterRoleBindingList{}
+	list := &v1alpha1.ClusterRoleBindingList{ListMeta: obj.(*v1alpha1.ClusterRoleBindingList).ListMeta}
 	for _, item := range obj.(*v1alpha1.ClusterRoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1alpha1/fake/fake_role.go
+++ b/kubernetes/typed/rbac/v1alpha1/fake/fake_role.go
@@ -62,7 +62,7 @@ func (c *FakeRoles) List(opts v1.ListOptions) (result *v1alpha1.RoleList, err er
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.RoleList{}
+	list := &v1alpha1.RoleList{ListMeta: obj.(*v1alpha1.RoleList).ListMeta}
 	for _, item := range obj.(*v1alpha1.RoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1alpha1/fake/fake_rolebinding.go
+++ b/kubernetes/typed/rbac/v1alpha1/fake/fake_rolebinding.go
@@ -62,7 +62,7 @@ func (c *FakeRoleBindings) List(opts v1.ListOptions) (result *v1alpha1.RoleBindi
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.RoleBindingList{}
+	list := &v1alpha1.RoleBindingList{ListMeta: obj.(*v1alpha1.RoleBindingList).ListMeta}
 	for _, item := range obj.(*v1alpha1.RoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1beta1/fake/fake_clusterrole.go
+++ b/kubernetes/typed/rbac/v1beta1/fake/fake_clusterrole.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoles) List(opts v1.ListOptions) (result *v1beta1.ClusterRol
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.ClusterRoleList{}
+	list := &v1beta1.ClusterRoleList{ListMeta: obj.(*v1beta1.ClusterRoleList).ListMeta}
 	for _, item := range obj.(*v1beta1.ClusterRoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1beta1/fake/fake_clusterrolebinding.go
+++ b/kubernetes/typed/rbac/v1beta1/fake/fake_clusterrolebinding.go
@@ -59,7 +59,7 @@ func (c *FakeClusterRoleBindings) List(opts v1.ListOptions) (result *v1beta1.Clu
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.ClusterRoleBindingList{}
+	list := &v1beta1.ClusterRoleBindingList{ListMeta: obj.(*v1beta1.ClusterRoleBindingList).ListMeta}
 	for _, item := range obj.(*v1beta1.ClusterRoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1beta1/fake/fake_role.go
+++ b/kubernetes/typed/rbac/v1beta1/fake/fake_role.go
@@ -62,7 +62,7 @@ func (c *FakeRoles) List(opts v1.ListOptions) (result *v1beta1.RoleList, err err
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.RoleList{}
+	list := &v1beta1.RoleList{ListMeta: obj.(*v1beta1.RoleList).ListMeta}
 	for _, item := range obj.(*v1beta1.RoleList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/rbac/v1beta1/fake/fake_rolebinding.go
+++ b/kubernetes/typed/rbac/v1beta1/fake/fake_rolebinding.go
@@ -62,7 +62,7 @@ func (c *FakeRoleBindings) List(opts v1.ListOptions) (result *v1beta1.RoleBindin
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1beta1.RoleBindingList{}
+	list := &v1beta1.RoleBindingList{ListMeta: obj.(*v1beta1.RoleBindingList).ListMeta}
 	for _, item := range obj.(*v1beta1.RoleBindingList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/scheduling/v1alpha1/fake/fake_priorityclass.go
+++ b/kubernetes/typed/scheduling/v1alpha1/fake/fake_priorityclass.go
@@ -59,7 +59,7 @@ func (c *FakePriorityClasses) List(opts v1.ListOptions) (result *v1alpha1.Priori
 	if label == nil {
 		label = labels.Everything()
 	}
-	list := &v1alpha1.PriorityClassList{}
+	list := &v1alpha1.PriorityClassList{ListMeta: obj.(*v1alpha1.PriorityClassList).ListMeta}
 	for _, item := range obj.(*v1alpha1.PriorityClassList).Items {
 		if label.Matches(labels.Set(item.Labels)) {
 			list.Items = append(list.Items, item)
--- a/kubernetes/typed/scheduling/v1beta1/doc.go
+++ b/kubernetes/typed/scheduling/v1beta1/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// This package has the automatically generated typed clients.
+package v1beta1
--- a/kubernetes/typed/scheduling/v1beta1/fake/doc.go
+++ b/kubernetes/typed/scheduling/v1beta1/fake/doc.go
@@ -0,0 +1,20 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+// Package fake has the automatically generated clients.
+package fake
--- a/kubernetes/typed/scheduling/v1beta1/fake/fake_priorityclass.go
+++ b/kubernetes/typed/scheduling/v1beta1/fake/fake_priorityclass.go
@@ -0,0 +1,120 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1beta1 "k8s.io/api/scheduling/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	labels "k8s.io/apimachinery/pkg/labels"
+	schema "k8s.io/apimachinery/pkg/runtime/schema"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	testing "k8s.io/client-go/testing"
+)
+
+// FakePriorityClasses implements PriorityClassInterface
+type FakePriorityClasses struct {
+	Fake *FakeSchedulingV1beta1
+}
+
+var priorityclassesResource = schema.GroupVersionResource{Group: "scheduling.k8s.io", Version: "v1beta1", Resource: "priorityclasses"}
+
+var priorityclassesKind = schema.GroupVersionKind{Group: "scheduling.k8s.io", Version: "v1beta1", Kind: "PriorityClass"}
+
+// Get takes name of the priorityClass, and returns the corresponding priorityClass object, and an error if there is any.
+func (c *FakePriorityClasses) Get(name string, options v1.GetOptions) (result *v1beta1.PriorityClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootGetAction(priorityclassesResource, name), &v1beta1.PriorityClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PriorityClass), err
+}
+
+// List takes label and field selectors, and returns the list of PriorityClasses that match those selectors.
+func (c *FakePriorityClasses) List(opts v1.ListOptions) (result *v1beta1.PriorityClassList, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootListAction(priorityclassesResource, priorityclassesKind, opts), &v1beta1.PriorityClassList{})
+	if obj == nil {
+		return nil, err
+	}
+
+	label, _, _ := testing.ExtractFromListOptions(opts)
+	if label == nil {
+		label = labels.Everything()
+	}
+	list := &v1beta1.PriorityClassList{ListMeta: obj.(*v1beta1.PriorityClassList).ListMeta}
+	for _, item := range obj.(*v1beta1.PriorityClassList).Items {
+		if label.Matches(labels.Set(item.Labels)) {
+			list.Items = append(list.Items, item)
+		}
+	}
+	return list, err
+}
+
+// Watch returns a watch.Interface that watches the requested priorityClasses.
+func (c *FakePriorityClasses) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	return c.Fake.
+		InvokesWatch(testing.NewRootWatchAction(priorityclassesResource, opts))
+}
+
+// Create takes the representation of a priorityClass and creates it.  Returns the server's representation of the priorityClass, and an error, if there is any.
+func (c *FakePriorityClasses) Create(priorityClass *v1beta1.PriorityClass) (result *v1beta1.PriorityClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootCreateAction(priorityclassesResource, priorityClass), &v1beta1.PriorityClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PriorityClass), err
+}
+
+// Update takes the representation of a priorityClass and updates it. Returns the server's representation of the priorityClass, and an error, if there is any.
+func (c *FakePriorityClasses) Update(priorityClass *v1beta1.PriorityClass) (result *v1beta1.PriorityClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootUpdateAction(priorityclassesResource, priorityClass), &v1beta1.PriorityClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PriorityClass), err
+}
+
+// Delete takes name of the priorityClass and deletes it. Returns an error if one occurs.
+func (c *FakePriorityClasses) Delete(name string, options *v1.DeleteOptions) error {
+	_, err := c.Fake.
+		Invokes(testing.NewRootDeleteAction(priorityclassesResource, name), &v1beta1.PriorityClass{})
+	return err
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *FakePriorityClasses) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	action := testing.NewRootDeleteCollectionAction(priorityclassesResource, listOptions)
+
+	_, err := c.Fake.Invokes(action, &v1beta1.PriorityClassList{})
+	return err
+}
+
+// Patch applies the patch and returns the patched priorityClass.
+func (c *FakePriorityClasses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PriorityClass, err error) {
+	obj, err := c.Fake.
+		Invokes(testing.NewRootPatchSubresourceAction(priorityclassesResource, name, data, subresources...), &v1beta1.PriorityClass{})
+	if obj == nil {
+		return nil, err
+	}
+	return obj.(*v1beta1.PriorityClass), err
+}
--- a/kubernetes/typed/scheduling/v1beta1/fake/fake_scheduling_client.go
+++ b/kubernetes/typed/scheduling/v1beta1/fake/fake_scheduling_client.go
@@ -0,0 +1,40 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package fake
+
+import (
+	v1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
+	rest "k8s.io/client-go/rest"
+	testing "k8s.io/client-go/testing"
+)
+
+type FakeSchedulingV1beta1 struct {
+	*testing.Fake
+}
+
+func (c *FakeSchedulingV1beta1) PriorityClasses() v1beta1.PriorityClassInterface {
+	return &FakePriorityClasses{c}
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *FakeSchedulingV1beta1) RESTClient() rest.Interface {
+	var ret *rest.RESTClient
+	return ret
+}
--- a/kubernetes/typed/scheduling/v1beta1/generated_expansion.go
+++ b/kubernetes/typed/scheduling/v1beta1/generated_expansion.go
@@ -1,4 +1,5 @@
-Copyright 2011-2016 Canonical Ltd.
+/*
+Copyright The Kubernetes Authors.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -11,3 +12,10 @@ distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1beta1
+
+type PriorityClassExpansion interface{}
--- a/kubernetes/typed/scheduling/v1beta1/priorityclass.go
+++ b/kubernetes/typed/scheduling/v1beta1/priorityclass.go
@@ -0,0 +1,147 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	v1beta1 "k8s.io/api/scheduling/v1beta1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	types "k8s.io/apimachinery/pkg/types"
+	watch "k8s.io/apimachinery/pkg/watch"
+	scheme "k8s.io/client-go/kubernetes/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+// PriorityClassesGetter has a method to return a PriorityClassInterface.
+// A group's client should implement this interface.
+type PriorityClassesGetter interface {
+	PriorityClasses() PriorityClassInterface
+}
+
+// PriorityClassInterface has methods to work with PriorityClass resources.
+type PriorityClassInterface interface {
+	Create(*v1beta1.PriorityClass) (*v1beta1.PriorityClass, error)
+	Update(*v1beta1.PriorityClass) (*v1beta1.PriorityClass, error)
+	Delete(name string, options *v1.DeleteOptions) error
+	DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error
+	Get(name string, options v1.GetOptions) (*v1beta1.PriorityClass, error)
+	List(opts v1.ListOptions) (*v1beta1.PriorityClassList, error)
+	Watch(opts v1.ListOptions) (watch.Interface, error)
+	Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PriorityClass, err error)
+	PriorityClassExpansion
+}
+
+// priorityClasses implements PriorityClassInterface
+type priorityClasses struct {
+	client rest.Interface
+}
+
+// newPriorityClasses returns a PriorityClasses
+func newPriorityClasses(c *SchedulingV1beta1Client) *priorityClasses {
+	return &priorityClasses{
+		client: c.RESTClient(),
+	}
+}
+
+// Get takes name of the priorityClass, and returns the corresponding priorityClass object, and an error if there is any.
+func (c *priorityClasses) Get(name string, options v1.GetOptions) (result *v1beta1.PriorityClass, err error) {
+	result = &v1beta1.PriorityClass{}
+	err = c.client.Get().
+		Resource("priorityclasses").
+		Name(name).
+		VersionedParams(&options, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// List takes label and field selectors, and returns the list of PriorityClasses that match those selectors.
+func (c *priorityClasses) List(opts v1.ListOptions) (result *v1beta1.PriorityClassList, err error) {
+	result = &v1beta1.PriorityClassList{}
+	err = c.client.Get().
+		Resource("priorityclasses").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Do().
+		Into(result)
+	return
+}
+
+// Watch returns a watch.Interface that watches the requested priorityClasses.
+func (c *priorityClasses) Watch(opts v1.ListOptions) (watch.Interface, error) {
+	opts.Watch = true
+	return c.client.Get().
+		Resource("priorityclasses").
+		VersionedParams(&opts, scheme.ParameterCodec).
+		Watch()
+}
+
+// Create takes the representation of a priorityClass and creates it.  Returns the server's representation of the priorityClass, and an error, if there is any.
+func (c *priorityClasses) Create(priorityClass *v1beta1.PriorityClass) (result *v1beta1.PriorityClass, err error) {
+	result = &v1beta1.PriorityClass{}
+	err = c.client.Post().
+		Resource("priorityclasses").
+		Body(priorityClass).
+		Do().
+		Into(result)
+	return
+}
+
+// Update takes the representation of a priorityClass and updates it. Returns the server's representation of the priorityClass, and an error, if there is any.
+func (c *priorityClasses) Update(priorityClass *v1beta1.PriorityClass) (result *v1beta1.PriorityClass, err error) {
+	result = &v1beta1.PriorityClass{}
+	err = c.client.Put().
+		Resource("priorityclasses").
+		Name(priorityClass.Name).
+		Body(priorityClass).
+		Do().
+		Into(result)
+	return
+}
+
+// Delete takes name of the priorityClass and deletes it. Returns an error if one occurs.
+func (c *priorityClasses) Delete(name string, options *v1.DeleteOptions) error {
+	return c.client.Delete().
+		Resource("priorityclasses").
+		Name(name).
+		Body(options).
+		Do().
+		Error()
+}
+
+// DeleteCollection deletes a collection of objects.
+func (c *priorityClasses) DeleteCollection(options *v1.DeleteOptions, listOptions v1.ListOptions) error {
+	return c.client.Delete().
+		Resource("priorityclasses").
+		VersionedParams(&listOptions, scheme.ParameterCodec).
+		Body(options).
+		Do().
+		Error()
+}
+
+// Patch applies the patch and returns the patched priorityClass.
+func (c *priorityClasses) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta1.PriorityClass, err error) {
+	result = &v1beta1.PriorityClass{}
+	err = c.client.Patch(pt).
+		Resource("priorityclasses").
+		SubResource(subresources...).
+		Name(name).
+		Body(data).
+		Do().
+		Into(result)
+	return
+}
--- a/kubernetes/typed/scheduling/v1beta1/scheduling_client.go
+++ b/kubernetes/typed/scheduling/v1beta1/scheduling_client.go
@@ -0,0 +1,90 @@
+/*
+Copyright The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Code generated by client-gen. DO NOT EDIT.
+
+package v1beta1
+
+import (
+	v1beta1 "k8s.io/api/scheduling/v1beta1"
+	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
+	"k8s.io/client-go/kubernetes/scheme"
+	rest "k8s.io/client-go/rest"
+)
+
+type SchedulingV1beta1Interface interface {
+	RESTClient() rest.Interface
+	PriorityClassesGetter
+}
+
+// SchedulingV1beta1Client is used to interact with features provided by the scheduling.k8s.io group.
+type SchedulingV1beta1Client struct {
+	restClient rest.Interface
+}
+
+func (c *SchedulingV1beta1Client) PriorityClasses() PriorityClassInterface {
+	return newPriorityClasses(c)
+}
+
+// NewForConfig creates a new SchedulingV1beta1Client for the given config.
+func NewForConfig(c *rest.Config) (*SchedulingV1beta1Client, error) {
+	config := *c
+	if err := setConfigDefaults(&config); err != nil {
+		return nil, err
+	}
+	client, err := rest.RESTClientFor(&config)
+	if err != nil {
+		return nil, err
+	}
+	return &SchedulingV1beta1Client{client}, nil
+}
+
+// NewForConfigOrDie creates a new SchedulingV1beta1Client for the given config and
+// panics if there is an error in the config.
+func NewForConfigOrDie(c *rest.Config) *SchedulingV1beta1Client {
+	client, err := NewForConfig(c)
+	if err != nil {
+		panic(err)
+	}
+	return client
+}
+
+// New creates a new SchedulingV1beta1Client for the given RESTClient.
+func New(c rest.Interface) *SchedulingV1beta1Client {
+	return &SchedulingV1beta1Client{c}
+}
+
+func setConfigDefaults(config *rest.Config) error {
+	gv := v1beta1.SchemeGroupVersion
+	config.GroupVersion = &gv
+	config.APIPath = "/apis"
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+
+	if config.UserAgent == "" {
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+
+	return nil
+}
+
+// RESTClient returns a RESTClient that is used to communicate
+// with API server by this client implementation.
+func (c *SchedulingV1beta1Client) RESTClient() rest.Interface {
+	if c == nil {
+		return nil
+	}
+	return c.restClient
+}
--- a/Show More
+++ b/Show More