Merge pull request #102 from caesarxuchao/fix-release-2.0

manually update release-2.0
manually update release-2.0, tracking k8s.io/kubernetes release 1.5, last commit is bde8578d9675129b7a2aa08f1b825ec6cc0f3420
2026-05-15 19:53:50 +00:00 · 2017-02-13 09:46:50 -08:00 · 2017-02-12 20:21:49 -08:00 · 2017-02-11 05:45:52 -08:00 · 2017-02-11 05:37:14 -08:00 · 2017-02-01 03:06:46 +00:00
1712 changed files with 521456 additions and 136759 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,31 +1,7 @@
-
-TODO: This document was neglected and is currently not complete. Working on
-fixing this.
-
-# HEAD (changes that will go into the next release)
-* Added dependency on k8s.io/apimachinery
-* Added generated listers and informers
-* CHANGED: pass typed options to dynamic client (https://github.com/kubernetes/kubernetes/pull/41887)
-
-# v2.0.0
-
-* Included bug fixes in k8s.io/kuberentes release-1.5 branch, up to commit 
-  bde8578d9675129b7a2aa08f1b825ec6cc0f3420
-
-# v2.0.0-alpha.1
-
-* Removed top-level version folder (e.g., 1.4 and 1.5), switching to maintaining separate versions
-  in separate branches.
-* Clientset supported multiple versions per API group
-* Added ThirdPartyResources example
-* API changes
-  * Apps API group graduated to v1beta1 
-  * Policy API group graduated to v1beta1
-  * Added support for batch/v2alpha1/cronjob
-  * Renamed PetSet to StatefulSet
-  
-
 # v1.5.0

-* Included the auth plugin (https://github.com/kubernetes/kubernetes/pull/33334)
-* Added timeout field to RESTClient config (https://github.com/kubernetes/kubernetes/pull/33958)
+## Changelog since v1.4.0
+
+### Added
+* Include the auth plugin (https://github.com/kubernetes/kubernetes/pull/33334)
+* Add timeout field to RESTClient config (https://github.com/kubernetes/kubernetes/pull/33958)
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -1,478 +1,335 @@
 {
-  "ImportPath": "k8s.io/client-go",
-  "GoVersion": "go1.8",
-  "GodepVersion": "v79",
-  "Packages": [
-    "./..."
-  ],
-  "Deps": [
-    {
-      "ImportPath": "cloud.google.com/go/compute/metadata",
-      "Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
-    },
-    {
-      "ImportPath": "cloud.google.com/go/internal",
-      "Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
-    },
-    {
-      "ImportPath": "github.com/PuerkitoBio/purell",
-      "Rev": "8a290539e2e8629dbc4e6bad948158f790ec31f4"
-    },
-    {
-      "ImportPath": "github.com/PuerkitoBio/urlesc",
-      "Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e"
-    },
-    {
-      "ImportPath": "github.com/coreos/go-oidc/http",
-      "Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
-    },
-    {
-      "ImportPath": "github.com/coreos/go-oidc/jose",
-      "Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
-    },
-    {
-      "ImportPath": "github.com/coreos/go-oidc/key",
-      "Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
-    },
-    {
-      "ImportPath": "github.com/coreos/go-oidc/oauth2",
-      "Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
-    },
-    {
-      "ImportPath": "github.com/coreos/go-oidc/oidc",
-      "Rev": "be73733bb8cc830d0205609b95d125215f8e9c70"
-    },
-    {
-      "ImportPath": "github.com/coreos/pkg/health",
-      "Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-    },
-    {
-      "ImportPath": "github.com/coreos/pkg/httputil",
-      "Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-    },
-    {
-      "ImportPath": "github.com/coreos/pkg/timeutil",
-      "Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
-    },
-    {
-      "ImportPath": "github.com/davecgh/go-spew/spew",
-      "Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
-    },
-    {
-      "ImportPath": "github.com/docker/distribution/digest",
-      "Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-    },
-    {
-      "ImportPath": "github.com/docker/distribution/reference",
-      "Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
-    },
-    {
-      "ImportPath": "github.com/emicklei/go-restful",
-      "Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
-    },
-    {
-      "ImportPath": "github.com/emicklei/go-restful/log",
-      "Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
-    },
-    {
-      "ImportPath": "github.com/emicklei/go-restful/swagger",
-      "Rev": "09691a3b6378b740595c1002f40c34dd5f218a22"
-    },
-    {
-      "ImportPath": "github.com/ghodss/yaml",
-      "Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
-    },
-    {
-      "ImportPath": "github.com/go-openapi/jsonpointer",
-      "Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
-    },
-    {
-      "ImportPath": "github.com/go-openapi/jsonreference",
-      "Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
-    },
-    {
-      "ImportPath": "github.com/go-openapi/spec",
-      "Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
-    },
-    {
-      "ImportPath": "github.com/go-openapi/swag",
-      "Rev": "1d0bd113de87027671077d3c71eb3ac5d7dbba72"
-    },
-    {
-      "ImportPath": "github.com/gogo/protobuf/proto",
-      "Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-    },
-    {
-      "ImportPath": "github.com/gogo/protobuf/sortkeys",
-      "Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
-    },
-    {
-      "ImportPath": "github.com/golang/glog",
-      "Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
-    },
-    {
-      "ImportPath": "github.com/golang/groupcache/lru",
-      "Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
-    },
-    {
-      "ImportPath": "github.com/golang/protobuf/proto",
-      "Rev": "8616e8ee5e20a1704615e6c8d7afcdac06087a67"
-    },
-    {
-      "ImportPath": "github.com/google/gofuzz",
-      "Rev": "44d81051d367757e1c7c6a5a86423ece9afcf63c"
-    },
-    {
-      "ImportPath": "github.com/howeyc/gopass",
-      "Rev": "3ca23474a7c7203e0a0a070fd33508f6efdb9b3d"
-    },
-    {
-      "ImportPath": "github.com/imdario/mergo",
-      "Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
-    },
-    {
-      "ImportPath": "github.com/jonboulle/clockwork",
-      "Rev": "72f9bd7c4e0c2a40055ab3d0f09654f730cce982"
-    },
-    {
-      "ImportPath": "github.com/juju/ratelimit",
-      "Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
-    },
-    {
-      "ImportPath": "github.com/mailru/easyjson/buffer",
-      "Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-    },
-    {
-      "ImportPath": "github.com/mailru/easyjson/jlexer",
-      "Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-    },
-    {
-      "ImportPath": "github.com/mailru/easyjson/jwriter",
-      "Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
-    },
-    {
-      "ImportPath": "github.com/pmezard/go-difflib/difflib",
-      "Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
-    },
-    {
-      "ImportPath": "github.com/spf13/pflag",
-      "Rev": "9ff6c6923cfffbcd502984b8e0c80539a94968b7"
-    },
-    {
-      "ImportPath": "github.com/stretchr/testify/assert",
-      "Rev": "e3a8ff8ce36581f87a15341206f205b1da467059"
-    },
-    {
-      "ImportPath": "github.com/ugorji/go/codec",
-      "Rev": "ded73eae5db7e7a0ef6f55aace87a2873c5d2b74"
-    },
-    {
-      "ImportPath": "golang.org/x/crypto/ssh/terminal",
-      "Rev": "d172538b2cfce0c13cee31e647d0367aa8cd2486"
-    },
-    {
-      "ImportPath": "golang.org/x/net/context",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/net/context/ctxhttp",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/net/http2",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/net/http2/hpack",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/net/idna",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/net/lex/httplex",
-      "Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
-    },
-    {
-      "ImportPath": "golang.org/x/oauth2",
-      "Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-    },
-    {
-      "ImportPath": "golang.org/x/oauth2/google",
-      "Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-    },
-    {
-      "ImportPath": "golang.org/x/oauth2/internal",
-      "Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-    },
-    {
-      "ImportPath": "golang.org/x/oauth2/jws",
-      "Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-    },
-    {
-      "ImportPath": "golang.org/x/oauth2/jwt",
-      "Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
-    },
-    {
-      "ImportPath": "golang.org/x/sys/unix",
-      "Rev": "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9"
-    },
-    {
-      "ImportPath": "golang.org/x/text/cases",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/internal/tag",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/language",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/runes",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/secure/bidirule",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/secure/precis",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/transform",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/unicode/bidi",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/unicode/norm",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "golang.org/x/text/width",
-      "Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/app_identity",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/base",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/datastore",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/log",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/modules",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "google.golang.org/appengine/internal/remote_api",
-      "Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
-    },
-    {
-      "ImportPath": "gopkg.in/inf.v0",
-      "Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
-    },
-    {
-      "ImportPath": "gopkg.in/yaml.v2",
-      "Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/api/equality",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/api/errors",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/api/meta",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/api/resource",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/apimachinery",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/apimachinery/announced",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/apimachinery/registered",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/conversion",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/conversion/queryparams",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/fields",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/labels",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/openapi",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/schema",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/json",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/protobuf",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/recognizer",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/streaming",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/runtime/serializer/versioning",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/selection",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/types",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/diff",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/errors",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/framer",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/httpstream",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/intstr",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/json",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/mergepatch",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/net",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/rand",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/runtime",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/sets",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/strategicpatch",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/validation",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/validation/field",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/wait",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/util/yaml",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/version",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/pkg/watch",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/third_party/forked/golang/json",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    },
-    {
-      "ImportPath": "k8s.io/apimachinery/third_party/forked/golang/reflect",
-      "Rev": "9603df80256c35a1dd4bc3037ed9690737af941b"
-    }
-  ]
+	"ImportPath": "k8s.io/client-go",
+	"GoVersion": "go1.7",
+	"GodepVersion": "v75",
+	"Packages": [
+		"./..."
+	],
+	"Deps": [
+		{
+			"ImportPath": "cloud.google.com/go/compute/metadata",
+			"Comment": "v0.1.0-115-g3b1ae45",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
+		},
+		{
+			"ImportPath": "cloud.google.com/go/internal",
+			"Comment": "v0.1.0-115-g3b1ae45",
+			"Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821"
+		},
+		{
+			"ImportPath": "github.com/PuerkitoBio/purell",
+			"Comment": "v1.0.0",
+			"Rev": "8a290539e2e8629dbc4e6bad948158f790ec31f4"
+		},
+		{
+			"ImportPath": "github.com/PuerkitoBio/urlesc",
+			"Rev": "5bd2802263f21d8788851d5305584c82a5c75d7e"
+		},
+		{
+			"ImportPath": "github.com/blang/semver",
+			"Comment": "v3.0.1",
+			"Rev": "31b736133b98f26d5e078ec9eb591666edfd091f"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/http",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/jose",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/key",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/oauth2",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/go-oidc/oidc",
+			"Rev": "5644a2f50e2d2d5ba0b474bc5bc55fea1925936d"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/health",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/httputil",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/coreos/pkg/timeutil",
+			"Comment": "v2-8-gfa29b1d",
+			"Rev": "fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8"
+		},
+		{
+			"ImportPath": "github.com/davecgh/go-spew/spew",
+			"Rev": "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d"
+		},
+		{
+			"ImportPath": "github.com/docker/distribution/digest",
+			"Comment": "v2.4.0-rc.1-38-gcd27f179",
+			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
+		},
+		{
+			"ImportPath": "github.com/docker/distribution/reference",
+			"Comment": "v2.4.0-rc.1-38-gcd27f179",
+			"Rev": "cd27f179f2c10c5d300e6d09025b538c475b0d51"
+		},
+		{
+			"ImportPath": "github.com/docker/spdystream",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+		},
+		{
+			"ImportPath": "github.com/docker/spdystream/spdy",
+			"Rev": "449fdfce4d962303d702fec724ef0ad181c92528"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful/log",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/emicklei/go-restful/swagger",
+			"Comment": "v1.2-79-g89ef8af",
+			"Rev": "89ef8af493ab468a45a42bb0d89a06fccdd2fb22"
+		},
+		{
+			"ImportPath": "github.com/ghodss/yaml",
+			"Rev": "73d445a93680fa1a78ae23a5839bad48f32ba1ee"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/jsonpointer",
+			"Rev": "46af16f9f7b149af66e5d1bd010e3574dc06de98"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/jsonreference",
+			"Rev": "13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/spec",
+			"Rev": "6aced65f8501fe1217321abf0749d354824ba2ff"
+		},
+		{
+			"ImportPath": "github.com/go-openapi/swag",
+			"Rev": "1d0bd113de87027671077d3c71eb3ac5d7dbba72"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/proto",
+			"Comment": "v0.2-33-ge18d7aa8",
+			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+		},
+		{
+			"ImportPath": "github.com/gogo/protobuf/sortkeys",
+			"Comment": "v0.2-33-ge18d7aa8",
+			"Rev": "e18d7aa8f8c624c915db340349aad4c49b10d173"
+		},
+		{
+			"ImportPath": "github.com/golang/glog",
+			"Rev": "44145f04b68cf362d9c4df2182967c2275eaefed"
+		},
+		{
+			"ImportPath": "github.com/golang/groupcache/lru",
+			"Rev": "02826c3e79038b59d737d3b1c0a1d937f71a4433"
+		},
+		{
+			"ImportPath": "github.com/golang/protobuf/proto",
+			"Rev": "8616e8ee5e20a1704615e6c8d7afcdac06087a67"
+		},
+		{
+			"ImportPath": "github.com/google/gofuzz",
+			"Rev": "bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5"
+		},
+		{
+			"ImportPath": "github.com/howeyc/gopass",
+			"Rev": "3ca23474a7c7203e0a0a070fd33508f6efdb9b3d"
+		},
+		{
+			"ImportPath": "github.com/imdario/mergo",
+			"Comment": "0.1.3-8-g6633656",
+			"Rev": "6633656539c1639d9d78127b7d47c622b5d7b6dc"
+		},
+		{
+			"ImportPath": "github.com/jonboulle/clockwork",
+			"Rev": "72f9bd7c4e0c2a40055ab3d0f09654f730cce982"
+		},
+		{
+			"ImportPath": "github.com/juju/ratelimit",
+			"Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/buffer",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/jlexer",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/mailru/easyjson/jwriter",
+			"Rev": "d5b7844b561a7bc640052f1b935f7b800330d7e0"
+		},
+		{
+			"ImportPath": "github.com/pborman/uuid",
+			"Rev": "ca53cad383cad2479bbba7f7a1a05797ec1386e4"
+		},
+		{
+			"ImportPath": "github.com/pmezard/go-difflib/difflib",
+			"Rev": "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
+		},
+		{
+			"ImportPath": "github.com/spf13/pflag",
+			"Rev": "5ccb023bc27df288a957c5e994cd44fd19619465"
+		},
+		{
+			"ImportPath": "github.com/stretchr/testify/assert",
+			"Comment": "v1.0-88-ge3a8ff8",
+			"Rev": "e3a8ff8ce36581f87a15341206f205b1da467059"
+		},
+		{
+			"ImportPath": "github.com/ugorji/go/codec",
+			"Rev": "f1f1a805ed361a0e078bb537e4ea78cd37dcf065"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/ssh/terminal",
+			"Rev": "1f22c0103821b9390939b6776727195525381532"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/context/ctxhttp",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/http2/hpack",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/idna",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/net/lex/httplex",
+			"Rev": "e90d6d0afc4c315a0d87a568ae68577cc15149a0"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/google",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/internal",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jws",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/oauth2/jwt",
+			"Rev": "3c3a985cb79f52a3190fbc056984415ca6763d01"
+		},
+		{
+			"ImportPath": "golang.org/x/sys/unix",
+			"Rev": "8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9"
+		},
+		{
+			"ImportPath": "golang.org/x/text/cases",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/internal/tag",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/language",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/runes",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/secure/bidirule",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/secure/precis",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/transform",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/bidi",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "golang.org/x/text/width",
+			"Rev": "2910a502d2bf9e43193af9d68ca516529614eed3"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/app_identity",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/base",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/datastore",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/log",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/modules",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "google.golang.org/appengine/internal/remote_api",
+			"Rev": "4f7eeb5305a4ba1966344836ba4af9996b7b4e05"
+		},
+		{
+			"ImportPath": "gopkg.in/inf.v0",
+			"Comment": "v0.9.0",
+			"Rev": "3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4"
+		},
+		{
+			"ImportPath": "gopkg.in/yaml.v2",
+			"Rev": "53feefa2559fb8dfa8d81baad31be332c97d6c77"
+		}
+	]
 }
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,157 +0,0 @@
-# Installing client-go
-
-## For the casual user
-
-Currently, there is no super easy way to use client-go.  Hopefully this will
-change soon. Simply running `go get k8s.io/client-go/...` will leave you with a
-library that can't practically be used.  It is important to synchronize your
-dependencies with the ones that are required by the library.
-
-Note: the official go policy is that libraries should not vendor their
-dependencies. This is unworkable for us, since our dependencies change and HEAD
-on every dependency has not necessarily been tested with client-go. In fact,
-HEAD from all dependencies may not even compile with client-go!
-
-## Dependency management for the serious (or reluctant) user
-
-Reasons why you might need to use a dependency management system:
-* You use a dependency that client-go also uses, and don't want two copies of
-  the dependency compiled into your application. For some dependencies with
-  singletons or global inits (e.g. `glog`) this wouldn't even compile...
-* You want to lock in a particular version (so you don't have to change your
-  code every time we change a public interface).
-* You want your install to be reproducible. For example, for your CI system or
-  for new team members.
-
-There are three tools you could in theory use for this. Instructions
-for each follows.
-
-### Dep
-
-[dep](https://github.com/golang/dep) is an up-and-coming dependency management tool,
-which has the goal of being accepted as part of the standard go toolchain. Its
-status is currently alpha. However, it comes the closest to working easily out
-of the box.
-
-```sh
-$ go get github.com/golang/dep
-$ go install github.com/golang/dep/cmd/dep
-
-# Make sure you have a go file in your directory which imports k8s.io/client-go
-# first--I suggest copying one of the examples.
-$ dep init
-$ dep ensure k8s.io/client-go@^2.0.0
-```
-
-Then you can try one of the
-[examples](https://github.com/kubernetes/client-go/tree/v2.0.0/examples/) from
-the 2.0.0 release.
-
-This will set up a `vendor` directory in your current directory, add `k8s.io/client-go`
-to it, and flatten all of `k8s.io/client-go`'s dependencies into that vendor directory,
-so that your code and `client-go` will both get the same copy of each
-dependency.
-
-After installing like this, you could either use dep for your other
-dependencies, or copy everything in the `vendor` directory into your
-`$GOPATH/src` directory and proceed as if you had done a fancy `go get` that
-flattened dependencies sanely.
-
-One thing to note about dep is that it will omit dependencies that aren't
-actually used, and some dependencies of `client-go` are used only if you import
-one of the plugins (for example, the auth plugins). So you may need to run `dep
-ensure` again if you start importing a plugin that you weren't using before.
-
-### Godep
-
-[godep](https://github.com/tools/godep) is an older dependency management tool, which is
-used by the main Kubernetes repo and `client-go` to manage dependencies.
-
-Before proceeding with the below instructions, you should ensure that your
-$GOPATH is empty except for containing your own package and its dependencies,
-and you have a copy of godep somewhere in your $PATH.
-
-To install `client-go` and place its dependencies in your `$GOPATH`:
-
-```sh
-go get k8s.io/client-go/...
-cd $GOPATH/src/k8s.io/client-go
-git checkout v2.0.0
-# cd 1.5 # only necessary with 1.5 and 1.4 clients.
-godep restore ./...
-```
-
-At this point, `client-go`'s dependencies have been placed in your $GOPATH, but
-if you were to build, `client-go` would still see its own copy of its
-dependencies in its `vendor` directory. You have two options at this point.
-
-If you would like to keep dependencies in your own project's vendor directory,
-then you can continue like this:
-
-```sh
-cd $GOPATH/src/<my-pkg>
-godep save ./...
-```
-
-Alternatively, if you want to build using the dependencies in your `$GOPATH`,
-then `rm -rf vendor/` to remove `client-go`'s copy of its dependencies.
-
-### Glide
-
-[Glide](https://github.com/Masterminds/glide) is another popular dependency
-management tool for Go. Glide will manage your /vendor directory, but unlike
-godep, will not use or modify your $GOPATH (there's no equivalent of
-`godep restore` or `godep save`).
-
-Generally, it's best to avoid Glide's many subcommands, favoring modifying
-Glide's manifest file (`glide.yaml`) directly, then running
-`glide update --strip-vendor`. First create a `glide.yaml` file at the root of
-your project:
-
-```yaml
-package: ( your project's import path ) # e.g. github.com/foo/bar
-import:
- package: k8s.io/client-go
-  version: v2.0.0
-```
-
-Second, add a Go file that imports `client-go` somewhere in your project,
-otherwise `client-go`'s dependencies will not be added to your project's
-vendor/. Then run the following command in the same directory as `glide.yaml`:
-
-```sh
-glide update --strip-vendor
-```
-
-This can also be abbreviated as:
-
-```sh
-glide up -v
-```
-
-At this point, `k8s.io/client-go` should be added to your project's vendor/.
-`client-go`'s dependencies should be flattened and be added to your project's
-vendor/ as well.
-
-Glide will detect the versions of dependencies `client-go` specified in
-`client-go`'s Godep.json file, and automatically set the versions of these
-imports in your /vendor directory. It will also record the detected version of
-all dependencies in the `glide.lock` file.
-
-Projects that require a different version of a dependency than `client-go`
-requests can override the version manually in `glide.yaml`. For example:
-
-```yaml
-package: ( your project's import path ) # e.g. github.com/foo/bar
-import:
- package: k8s.io/client-go
-  version: v2.0.0
-# Use a newer version of go-spew even though client-go wants an old one.
- package: github.com/davecgh/go-spew
-  version: v1.1.0
-```
-
-After modifying, run `glide up -v` again to re-populate your /vendor directory.
-
-Optionally, Glide users can also use [`glide-vc`](https://github.com/sgotti/glide-vc)
-after running `glide up -v` to remove unused files from /vendor.
--- a/2
+++ b/2
@@ -187,7 +187,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2014 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.
--- a/44
+++ b/44
@@ -1,44 +0,0 @@
-approvers:
- caesarxuchao
- deads2k
- krousey
- lavalamp
- smarterclayton
-reviewers:
- thockin
- lavalamp
- smarterclayton
- wojtek-t
- deads2k
- yujuhong
- derekwaynecarr
- caesarxuchao
- vishh
- mikedanese
- liggitt
- nikhiljindal
- bprashanth
- gmarek
- erictune
- davidopp
- pmorie
- sttts
- kargakis
- dchen1107
- saad-ali
- zmerlynn
- luxas
- janetkuo
- justinsb
- roberthbailey
- ncdc
- timstclair
- yifan-gu
- eparis
- mwielgus
- timothysc
- feiskyer
- jlowdermilk
- soltysh
- piosz
- jsafrane
--- a/README.md
+++ b/README.md
@@ -2,10 +2,6 @@

 Go clients for talking to a [kubernetes](http://kubernetes.io/) cluster.

-We currently recommend using the v2.0.0 tag. See [INSTALL.md](/INSTALL.md) for
-detailed installation instructions. `go get k8s.io/client-go/...` works, but
-will give you head and doesn't handle the dependencies well.
-
 ## Table of Contents
 
 - [What's included](#whats-included)
@@ -17,6 +13,7 @@ will give you head and doesn't handle the dependencies well.
 - [How to get it](#how-to-get-it)
 - [How to use it](#how-to-use-it)
 - [Dependency management](#dependency-management)
+- [Reporting bugs](#reporting-bugs)
 - [Contributing code](#contributing-code)

 ### What's included
@@ -29,106 +26,40 @@ will give you head and doesn't handle the dependencies well.

 ### Versioning

-`client-go` follows [semver](http://semver.org/). We will not make
-backwards-incompatible changes without incrementing the major version number. A
-change is backwards-incompatible either if it *i)* changes the public interfaces
-of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported
-versions of Kubernetes clusters.
+`client-go` version numbers are unrelated to Kubernetes version numbers. Please see the [compatibility matrix](#compatibility-matrix) for the compatible Kubernetes clusters.

-Changes that add features in a backwards-compatible way will result in bumping
-the minor version (second digit) number.
+`client-go` follows [semver](http://semver.org/). We will not make backwards-incompatible changes without incrementing the major version number. A change is backwards-incompatible either if it *i)* changes the public interfaces of `client-go`, or *ii)* makes `client-go` incompatible with otherwise supported versions of Kubernetes clusters.

-Bugfixes will result in the patch version (third digit) changing. PRs that are
-cherry-picked into an older Kubernetes release branch will result in an update
-to the corresponding branch in `client-go`, with a corresponding new tag
-changing the patch version.
+We will create a new branch for each increment in the major version number or minor version number. We will create a new tag for each increment in the patch version number. See [semver](http://semver.org/) for definitions of major, minor, and patch.

-A consequence of this is that `client-go` version numbers will be unrelated to
-Kubernetes version numbers.
-
-#### Branches and tags.
-
-We will create a new branch and tag for each increment in the major version number or
-minor version number. We will create only a new tag for each increment in the patch
-version number. See [semver](http://semver.org/) for definitions of major,
-minor, and patch.
-
-The master branch will track HEAD in the main Kubernetes repo and
-accumulate changes. Consider HEAD to have the version `x.(y+1).0-alpha` or
-`(x+1).0.0-alpha` (depending on whether it has accumulated a breaking change or
-not), where `x` and `y` are the current major and minor versions.
+The master branch will track the head in the main Kubernetes repo and accumulating changes. We will make a new client-go major/minor/patch version when:
+* A new major (very rare) or a new minor version is released in the Kubernetes main repository.
+* A feature or a bug fix in the master branch is popular and users want it in a stable branch or with a stable tag. 

 #### Compatibility: your code <-> client-go

-`client-go` follows [semver](http://semver.org/), so until the major version of
-client-go gets increased, your code will compile and will continue to work with
-explicitly supported versions of Kubernetes clusters. You must use a dependency
-management system and pin a specific major version of `client-go` to get this
-benefit, as HEAD follows the upstream Kubernetes repo.
+`client-go` follows [semver](http://semver.org/), so until the major version of client-go gets increased, your code will compile and will continue to work with explicitly supported versions of Kubernetes clusters.

 #### Compatibility: client-go <-> Kubernetes clusters

-Since Kubernetes is backwards compatible with clients, older `client-go`
-versions will work with many different Kubernetes cluster versions.
-
-We will backport bugfixes--but not new features--into older versions of
-`client-go`.
+`client-go` versions will be backwards compatible with many Kubernetes clusters. As we increment `client-go` versions, we will note which Kubernetes versions we expect them to work with. 

+We do not back-port new Kubernetes features into older clients. If you need a new feature, you are expected to upgrade to the new client. You can check out the [CHANGELOG](./CHANGELOG.md) for notable changes.

 #### Compatibility matrix

-|                | Kubernetes 1.3 | Kubernetes 1.4 | Kubernetes 1.5 | Kubernetes 1.6 (not released yet) |
-|----------------|----------------|----------------|----------------|----------------|
-| client-go 1.4  | +              | ✓              | -              | -              |
-| client-go 1.5  | +              | +              | -              | -              |
-| client-go 2.0  | +              | +              | ✓              | -              |
-| client-go HEAD | +              | +              | +              | ✓              |
-
-Key:
-
-* ✓ Exactly the same features / API objects in both client-go and the Kubernetes
-  version.
-* + client-go has features or api objects that may not be present in the
-  Kubernetes cluster, but everything they have in common will work.
-* - The Kubernetes cluster has features the client-go library can't use
-  (additional API objects, etc).
-
-See the [CHANGELOG](./CHANGELOG.md) for a detailed description of changes
-between client-go versions.
-
-| Branch         | Canonical source code location       | Maintenance status            |
-|----------------|--------------------------------------|-------------------------------|
-| client-go 1.4  | Kubernetes main repo, 1.4 branch     | = -                           |
-| client-go 1.5  | Kubernetes main repo, 1.5 branch     | = -                           |
-| client-go 2.0  | Kubernetes main repo, 1.5 branch     | ✓                             |
-| client-go HEAD | Kubernetes main repo, master branch  | ✓                             |
-
-Key:
-
-* ✓ Changes in main Kubernetes repo are actively published to client-go by a bot
-* = Maintenance is manual, only severe security bugs will be patched.
-* - Deprecated; please upgrade.
-
-#### Deprecation policy
-
-We will maintain branches for at least six months after their first stable tag
-is cut. (E.g., the clock for the release-2.0 branch started ticking when we
-tagged v2.0.0, not when we made the first alpha.) This policy applies to
-every version greater than or equal to 2.0.
+* **client-go/1.4** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.
+* **client-go/1.5** is compatible with Kubernetes 1.3 through 1.5; it includes all features provided by Kubernetes 1.4.

 #### Why do the 1.4 and 1.5 branch contain top-level folder named after the version?

-For the initial release of client-go, we thought it would be easiest to keep
-separate directories for each minor version. That soon proved to be a mistake.
-We are keeping the top-level folders in the 1.4 and 1.5 branches so that
-existing users won't be broken.
+1.4 and 1.5 branch keep the top-level folders so they do not break the import lines of existing users. These top-level folders are deprecated and are removed from the master branch and future branches.

 ### How to get it

-You can use `go get k8s.io/client-go/...` to get client-go, but **you will get
-the unstable master branch** and `client-go`'s vendored dependencies will not be
-added to your `$GOPATH`. So we think most users will want to use a dependency
-management system. See [INSTALL.md](/INSTALL.md) for detailed instructions.
+If you use `go get` to get client-go, **you will get the unstable master branch!** You can `git checkout` a stable branch.
+
+We recommend using a vendor tool, like [godep](https://github.com/tools/godep), [glide](https://github.com/Masterminds/glide), or [govendor](https://github.com/kardianos/govendor) to track a stable version of `client-go`.

 ### How to use it

@@ -140,5 +71,9 @@ If your application depends on a package that client-go depends on, and you let
 * run `godep restore` ([godep](https://github.com/tools/godep)) in the client-go/ folder, then remove the vendor folder of client-go. Then the packages in your GOPATH will be the only copy
 * or run `godep save` in your application folder to flatten all dependencies.

+### Reporting bugs
+
+Please report bugs to the main Kubernetes [repository](https://github.com/kubernetes/kubernetes/issues/new).
+
 ### Contributing code
 Please send pull requests against the client packages in the Kubernetes main [repository](https://github.com/kubernetes/kubernetes), and run the `/staging/copy.sh` script to update the staging area in the main repository. Changes in the staging area will be published to this repository every day.
--- a/discovery/discovery_client.go
+++ b/discovery/discovery_client.go
@@ -25,24 +25,20 @@ import (

 	"github.com/emicklei/go-restful/swagger"

-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/version"
 	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/unversioned"
 	"k8s.io/client-go/pkg/api/v1"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 )

-// defaultRetries is the number of times a resource discovery is repeated if an api group disappears on the fly (e.g. ThirdPartyResources).
-const defaultRetries = 2
-
 // DiscoveryInterface holds the methods that discover server-supported API groups,
 // versions and resources.
 type DiscoveryInterface interface {
-	RESTClient() restclient.Interface
+	RESTClient() rest.Interface
 	ServerGroupsInterface
 	ServerResourcesInterface
 	ServerVersionInterface
@@ -62,21 +58,21 @@ type CachedDiscoveryInterface interface {
 type ServerGroupsInterface interface {
 	// ServerGroups returns the supported groups, with information like supported versions and the
 	// preferred version.
-	ServerGroups() (*metav1.APIGroupList, error)
+	ServerGroups() (*unversioned.APIGroupList, error)
 }

 // ServerResourcesInterface has methods for obtaining supported resources on the API server
 type ServerResourcesInterface interface {
 	// ServerResourcesForGroupVersion returns the supported resources for a group and version.
-	ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error)
+	ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error)
 	// ServerResources returns the supported resources for all groups and versions.
-	ServerResources() ([]*metav1.APIResourceList, error)
+	ServerResources() (map[string]*unversioned.APIResourceList, error)
 	// ServerPreferredResources returns the supported resources with the version preferred by the
 	// server.
-	ServerPreferredResources() ([]*metav1.APIResourceList, error)
+	ServerPreferredResources() ([]unversioned.GroupVersionResource, error)
 	// ServerPreferredNamespacedResources returns the supported namespaced resources with the
 	// version preferred by the server.
-	ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error)
+	ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error)
 }

 // ServerVersionInterface has a method for retrieving the server's version.
@@ -88,23 +84,23 @@ type ServerVersionInterface interface {
 // SwaggerSchemaInterface has a method to retrieve the swagger schema.
 type SwaggerSchemaInterface interface {
 	// SwaggerSchema retrieves and parses the swagger API schema the server supports.
-	SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error)
+	SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error)
 }

 // DiscoveryClient implements the functions that discover server-supported API groups,
 // versions and resources.
 type DiscoveryClient struct {
-	restClient restclient.Interface
+	restClient rest.Interface

 	LegacyPrefix string
 }

-// Convert metav1.APIVersions to metav1.APIGroup. APIVersions is used by legacy v1, so
+// Convert unversioned.APIVersions to unversioned.APIGroup. APIVersions is used by legacy v1, so
 // group would be "".
-func apiVersionsToAPIGroup(apiVersions *metav1.APIVersions) (apiGroup metav1.APIGroup) {
-	groupVersions := []metav1.GroupVersionForDiscovery{}
+func apiVersionsToAPIGroup(apiVersions *unversioned.APIVersions) (apiGroup unversioned.APIGroup) {
+	groupVersions := []unversioned.GroupVersionForDiscovery{}
 	for _, version := range apiVersions.Versions {
-		groupVersion := metav1.GroupVersionForDiscovery{
+		groupVersion := unversioned.GroupVersionForDiscovery{
 			GroupVersion: version,
 			Version:      version,
 		}
@@ -118,12 +114,12 @@ func apiVersionsToAPIGroup(apiVersions *metav1.APIVersions) (apiGroup metav1.API

 // ServerGroups returns the supported groups, with information like supported versions and the
 // preferred version.
-func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err error) {
+func (d *DiscoveryClient) ServerGroups() (apiGroupList *unversioned.APIGroupList, err error) {
 	// Get the groupVersions exposed at /api
-	v := &metav1.APIVersions{}
+	v := &unversioned.APIVersions{}
 	err = d.restClient.Get().AbsPath(d.LegacyPrefix).Do().Into(v)
-	apiGroup := metav1.APIGroup{}
-	if err == nil && len(v.Versions) != 0 {
+	apiGroup := unversioned.APIGroup{}
+	if err == nil {
 		apiGroup = apiVersionsToAPIGroup(v)
 	}
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
@@ -131,25 +127,23 @@ func (d *DiscoveryClient) ServerGroups() (apiGroupList *metav1.APIGroupList, err
 	}

 	// Get the groupVersions exposed at /apis
-	apiGroupList = &metav1.APIGroupList{}
+	apiGroupList = &unversioned.APIGroupList{}
 	err = d.restClient.Get().AbsPath("/apis").Do().Into(apiGroupList)
 	if err != nil && !errors.IsNotFound(err) && !errors.IsForbidden(err) {
 		return nil, err
 	}
 	// to be compatible with a v1.0 server, if it's a 403 or 404, ignore and return whatever we got from /api
 	if err != nil && (errors.IsNotFound(err) || errors.IsForbidden(err)) {
-		apiGroupList = &metav1.APIGroupList{}
+		apiGroupList = &unversioned.APIGroupList{}
 	}

-	// append the group retrieved from /api to the list if not empty
-	if len(v.Versions) != 0 {
-		apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
-	}
+	// append the group retrieved from /api to the list
+	apiGroupList.Groups = append(apiGroupList.Groups, apiGroup)
 	return apiGroupList, nil
 }

 // ServerResourcesForGroupVersion returns the supported resources for a group and version.
-func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (resources *metav1.APIResourceList, err error) {
+func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (resources *unversioned.APIResourceList, err error) {
 	url := url.URL{}
 	if len(groupVersion) == 0 {
 		return nil, fmt.Errorf("groupVersion shouldn't be empty")
@@ -159,9 +153,7 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	} else {
 		url.Path = "/apis/" + groupVersion
 	}
-	resources = &metav1.APIResourceList{
-		GroupVersion: groupVersion,
-	}
+	resources = &unversioned.APIResourceList{}
 	err = d.restClient.Get().AbsPath(url.String()).Do().Into(resources)
 	if err != nil {
 		// ignore 403 or 404 error to be compatible with an v1.0 server.
@@ -173,49 +165,28 @@ func (d *DiscoveryClient) ServerResourcesForGroupVersion(groupVersion string) (r
 	return resources, nil
 }

-// serverResources returns the supported resources for all groups and versions.
-func (d *DiscoveryClient) serverResources(failEarly bool) ([]*metav1.APIResourceList, error) {
+// ServerResources returns the supported resources for all groups and versions.
+func (d *DiscoveryClient) ServerResources() (map[string]*unversioned.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
-				if failEarly {
-					return nil, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-				}
-				continue
-			}
-
-			result = append(result, resources)
+	groupVersions := unversioned.ExtractGroupVersions(apiGroups)
+	result := map[string]*unversioned.APIResourceList{}
+	for _, groupVersion := range groupVersions {
+		resources, err := d.ServerResourcesForGroupVersion(groupVersion)
+		if err != nil {
+			return nil, err
 		}
+		result[groupVersion] = resources
 	}
-
-	if len(failedGroups) == 0 {
-		return result, nil
-	}
-
-	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-}
-
-// ServerResources returns the supported resources for all groups and versions.
-func (d *DiscoveryClient) ServerResources() ([]*metav1.APIResourceList, error) {
-	return withRetries(defaultRetries, d.serverResources)
+	return result, nil
 }

 // ErrGroupDiscoveryFailed is returned if one or more API groups fail to load.
 type ErrGroupDiscoveryFailed struct {
 	// Groups is a list of the groups that failed to load and the error cause
-	Groups map[schema.GroupVersion]error
+	Groups map[unversioned.GroupVersion]error
 }

 // Error implements the error interface
@@ -235,86 +206,78 @@ func IsGroupDiscoveryFailedError(err error) bool {
 	return err != nil && ok
 }

-// serverPreferredResources returns the supported resources with the version preferred by the server.
-func (d *DiscoveryClient) serverPreferredResources(failEarly bool) ([]*metav1.APIResourceList, error) {
-	serverGroupList, err := d.ServerGroups()
-	if err != nil {
-		return nil, err
-	}
+// serverPreferredResources returns the supported resources with the version preferred by the
+// server. If namespaced is true, only namespaced resources will be returned.
+func (d *DiscoveryClient) serverPreferredResources(namespaced bool) ([]unversioned.GroupVersionResource, error) {
+	// retry in case the groups supported by the server change after ServerGroup() returns.
+	const maxRetries = 2
+	var failedGroups map[unversioned.GroupVersion]error
+	var results []unversioned.GroupVersionResource
+	var resources map[unversioned.GroupResource]string
+RetrieveGroups:
+	for i := 0; i < maxRetries; i++ {
+		results = []unversioned.GroupVersionResource{}
+		resources = map[unversioned.GroupResource]string{}
+		failedGroups = make(map[unversioned.GroupVersion]error)
+		serverGroupList, err := d.ServerGroups()
+		if err != nil {
+			return results, err
+		}

-	result := []*metav1.APIResourceList{}
-	failedGroups := make(map[schema.GroupVersion]error)
-
-	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
-
-	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
-				if failEarly {
-					return nil, &ErrGroupDiscoveryFailed{Groups: failedGroups}
-				}
-				continue
-			}
-
-			// create empty list which is filled later in another loop
-			emptyApiResourceList := metav1.APIResourceList{
-				GroupVersion: version.GroupVersion,
-			}
-			gvApiResourceLists[groupVersion] = &emptyApiResourceList
-			result = append(result, &emptyApiResourceList)
-
-			for i := range apiResourceList.APIResources {
-				apiResource := &apiResourceList.APIResources[i]
-				if strings.Contains(apiResource.Name, "/") {
+		for _, apiGroup := range serverGroupList.Groups {
+			versions := apiGroup.Versions
+			for _, version := range versions {
+				groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: version.Version}
+				apiResourceList, err := d.ServerResourcesForGroupVersion(version.GroupVersion)
+				if err != nil {
+					if i < maxRetries-1 {
+						continue RetrieveGroups
+					}
+					failedGroups[groupVersion] = err
 					continue
 				}
-				gv := schema.GroupResource{Group: apiGroup.Name, Resource: apiResource.Name}
-				if _, ok := grApiResources[gv]; ok && version.Version != apiGroup.PreferredVersion.Version {
-					// only override with preferred version
-					continue
+				for _, apiResource := range apiResourceList.APIResources {
+					// ignore the root scoped resources if "namespaced" is true.
+					if namespaced && !apiResource.Namespaced {
+						continue
+					}
+					if strings.Contains(apiResource.Name, "/") {
+						continue
+					}
+					gvr := groupVersion.WithResource(apiResource.Name)
+					if _, ok := resources[gvr.GroupResource()]; ok {
+						if gvr.Version != apiGroup.PreferredVersion.Version {
+							continue
+						}
+						// remove previous entry, because it will be replaced with a preferred one
+						for i := range results {
+							if results[i].GroupResource() == gvr.GroupResource() {
+								results = append(results[:i], results[i+1:]...)
+							}
+						}
+					}
+					resources[gvr.GroupResource()] = gvr.Version
+					results = append(results, gvr)
 				}
-				grVersions[gv] = version.Version
-				grApiResources[gv] = apiResource
 			}
 		}
+		if len(failedGroups) == 0 {
+			return results, nil
+		}
 	}
-
-	// group selected APIResources according to GroupVersion into APIResourceLists
-	for groupResource, apiResource := range grApiResources {
-		version := grVersions[groupResource]
-		groupVersion := schema.GroupVersion{Group: groupResource.Group, Version: version}
-		apiResourceList := gvApiResourceLists[groupVersion]
-		apiResourceList.APIResources = append(apiResourceList.APIResources, *apiResource)
-	}
-
-	if len(failedGroups) == 0 {
-		return result, nil
-	}
-
-	return result, &ErrGroupDiscoveryFailed{Groups: failedGroups}
+	return results, &ErrGroupDiscoveryFailed{Groups: failedGroups}
 }

 // ServerPreferredResources returns the supported resources with the version preferred by the
 // server.
-func (d *DiscoveryClient) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
-	return withRetries(defaultRetries, func(retryEarly bool) ([]*metav1.APIResourceList, error) {
-		return d.serverPreferredResources(retryEarly)
-	})
+func (d *DiscoveryClient) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
+	return d.serverPreferredResources(false)
 }

 // 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 FilteredBy(ResourcePredicateFunc(func(groupVersion string, r *metav1.APIResource) bool {
-		return r.Namespaced
-	}), all), err
+func (d *DiscoveryClient) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+	return d.serverPreferredResources(true)
 }

 // ServerVersion retrieves and parses the server's version (git version).
@@ -332,7 +295,7 @@ func (d *DiscoveryClient) ServerVersion() (*version.Info, error) {
 }

 // SwaggerSchema retrieves and parses the swagger API schema the server supports.
-func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+func (d *DiscoveryClient) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
 	if version.Empty() {
 		return nil, fmt.Errorf("groupVersion cannot be empty")
 	}
@@ -341,7 +304,7 @@ func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.A
 	if err != nil {
 		return nil, err
 	}
-	groupVersions := metav1.ExtractGroupVersions(groupList)
+	groupVersions := unversioned.ExtractGroupVersions(groupList)
 	// This check also takes care the case that kubectl is newer than the running endpoint
 	if stringDoesntExistIn(version.String(), groupVersions) {
 		return nil, fmt.Errorf("API version: %v is not supported by the server. Use one of: %v", version, groupVersions)
@@ -365,48 +328,31 @@ func (d *DiscoveryClient) SwaggerSchema(version schema.GroupVersion) (*swagger.A
 	return &schema, nil
 }

-// withRetries retries the given recovery function in case the groups supported by the server change after ServerGroup() returns.
-func withRetries(maxRetries int, f func(failEarly bool) ([]*metav1.APIResourceList, error)) ([]*metav1.APIResourceList, error) {
-	var result []*metav1.APIResourceList
-	var err error
-	for i := 0; i < maxRetries; i++ {
-		failEarly := i < maxRetries-1
-		result, err = f(failEarly)
-		if err == nil {
-			return result, nil
-		}
-		if _, ok := err.(*ErrGroupDiscoveryFailed); !ok {
-			return nil, err
-		}
-	}
-	return result, err
-}
-
-func setDiscoveryDefaults(config *restclient.Config) error {
+func setDiscoveryDefaults(config *rest.Config) error {
 	config.APIPath = ""
 	config.GroupVersion = nil
 	codec := runtime.NoopEncoder{Decoder: api.Codecs.UniversalDecoder()}
 	config.NegotiatedSerializer = serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec})
 	if len(config.UserAgent) == 0 {
-		config.UserAgent = restclient.DefaultKubernetesUserAgent()
+		config.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
 	return nil
 }

 // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. This client
 // can be used to discover supported resources in the API server.
-func NewDiscoveryClientForConfig(c *restclient.Config) (*DiscoveryClient, error) {
+func NewDiscoveryClientForConfig(c *rest.Config) (*DiscoveryClient, error) {
 	config := *c
 	if err := setDiscoveryDefaults(&config); err != nil {
 		return nil, err
 	}
-	client, err := restclient.UnversionedRESTClientFor(&config)
+	client, err := rest.UnversionedRESTClientFor(&config)
 	return &DiscoveryClient{restClient: client, LegacyPrefix: "/api"}, err
 }

 // NewDiscoveryClientForConfig creates a new DiscoveryClient for the given config. If
 // there is an error, it panics.
-func NewDiscoveryClientForConfigOrDie(c *restclient.Config) *DiscoveryClient {
+func NewDiscoveryClientForConfigOrDie(c *rest.Config) *DiscoveryClient {
 	client, err := NewDiscoveryClientForConfig(c)
 	if err != nil {
 		panic(err)
@@ -416,7 +362,7 @@ func NewDiscoveryClientForConfigOrDie(c *restclient.Config) *DiscoveryClient {
 }

 // New creates a new DiscoveryClient for the given RESTClient.
-func NewDiscoveryClient(c restclient.Interface) *DiscoveryClient {
+func NewDiscoveryClient(c rest.Interface) *DiscoveryClient {
 	return &DiscoveryClient{restClient: c, LegacyPrefix: "/api"}
 }

@@ -431,7 +377,7 @@ func stringDoesntExistIn(str string, slice []string) bool {

 // RESTClient returns a RESTClient that is used to communicate
 // with API server by this client implementation.
-func (c *DiscoveryClient) RESTClient() restclient.Interface {
+func (c *DiscoveryClient) RESTClient() rest.Interface {
 	if c == nil {
 		return nil
 	}
--- a/discovery/discovery_client_test.go
+++ b/discovery/discovery_client_test.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-package discovery_test
+package discovery

 import (
 	"encoding/json"
@@ -25,13 +25,10 @@ import (

 	"github.com/emicklei/go-restful/swagger"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/apimachinery/pkg/version"
-	. "k8s.io/client-go/discovery"
+	"k8s.io/client-go/pkg/api/unversioned"
 	"k8s.io/client-go/pkg/api/v1"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 )

 func TestGetServerVersion(t *testing.T) {
@@ -51,7 +48,7 @@ func TestGetServerVersion(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})

 	got, err := client.ServerVersion()
 	if err != nil {
@@ -67,7 +64,7 @@ func TestGetServerGroupsWithV1Server(t *testing.T) {
 		var obj interface{}
 		switch req.URL.Path {
 		case "/api":
-			obj = &metav1.APIVersions{
+			obj = &unversioned.APIVersions{
 				Versions: []string{
 					"v1",
 				},
@@ -86,13 +83,13 @@ func TestGetServerGroupsWithV1Server(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
 	// ServerGroups should not return an error even if server returns error at /api and /apis
 	apiGroupList, err := client.ServerGroups()
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	groupVersions := metav1.ExtractGroupVersions(apiGroupList)
+	groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
 	if !reflect.DeepEqual(groupVersions, []string{"v1"}) {
 		t.Errorf("expected: %q, got: %q", []string{"v1"}, groupVersions)
 	}
@@ -104,13 +101,13 @@ func TestGetServerGroupsWithBrokenServer(t *testing.T) {
 			w.WriteHeader(statusCode)
 		}))
 		defer server.Close()
-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
 		// ServerGroups should not return an error even if server returns Not Found or Forbidden error at all end points
 		apiGroupList, err := client.ServerGroups()
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
 		}
-		groupVersions := metav1.ExtractGroupVersions(apiGroupList)
+		groupVersions := unversioned.ExtractGroupVersions(apiGroupList)
 		if len(groupVersions) != 0 {
 			t.Errorf("expected empty list, got: %q", groupVersions)
 		}
@@ -122,7 +119,7 @@ func TestGetServerResourcesWithV1Server(t *testing.T) {
 		var obj interface{}
 		switch req.URL.Path {
 		case "/api":
-			obj = &metav1.APIVersions{
+			obj = &unversioned.APIVersions{
 				Versions: []string{
 					"v1",
 				},
@@ -141,37 +138,37 @@ func TestGetServerResourcesWithV1Server(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
 	// ServerResources should not return an error even if server returns error at /api/v1.
-	serverResources, err := client.ServerResources()
+	resourceMap, err := client.ServerResources()
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	gvs := groupVersions(serverResources)
-	if !sets.NewString(gvs...).Has("v1") {
-		t.Errorf("missing v1 in resource list: %v", serverResources)
+	if _, found := resourceMap["v1"]; !found {
+		t.Errorf("missing v1 in resource map")
 	}
+
 }

 func TestGetServerResources(t *testing.T) {
-	stable := metav1.APIResourceList{
+	stable := unversioned.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 			{Name: "services", Namespaced: true, Kind: "Service"},
 			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
-	beta := metav1.APIResourceList{
-		GroupVersion: "extensions/v1beta1",
-		APIResources: []metav1.APIResource{
+	beta := unversioned.APIResourceList{
+		GroupVersion: "extensions/v1",
+		APIResources: []unversioned.APIResource{
 			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
 			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
 	tests := []struct {
-		resourcesList *metav1.APIResourceList
+		resourcesList *unversioned.APIResourceList
 		path          string
 		request       string
 		expectErr     bool
@@ -203,16 +200,16 @@ func TestGetServerResources(t *testing.T) {
 		case "/apis/extensions/v1beta1":
 			list = &beta
 		case "/api":
-			list = &metav1.APIVersions{
+			list = &unversioned.APIVersions{
 				Versions: []string{
 					"v1",
 				},
 			}
 		case "/apis":
-			list = &metav1.APIGroupList{
-				Groups: []metav1.APIGroup{
+			list = &unversioned.APIGroupList{
+				Groups: []unversioned.APIGroup{
 					{
-						Versions: []metav1.GroupVersionForDiscovery{
+						Versions: []unversioned.GroupVersionForDiscovery{
 							{GroupVersion: "extensions/v1beta1"},
 						},
 					},
@@ -233,7 +230,7 @@ func TestGetServerResources(t *testing.T) {
 		w.Write(output)
 	}))
 	defer server.Close()
-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
 	for _, test := range tests {
 		got, err := client.ServerResourcesForGroupVersion(test.request)
 		if test.expectErr {
@@ -251,14 +248,13 @@ func TestGetServerResources(t *testing.T) {
 		}
 	}

-	serverResources, err := client.ServerResources()
+	resourceMap, err := client.ServerResources()
 	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)
+		if _, found := resourceMap[api]; !found {
+			t.Errorf("missing expected api: %s", api)
 		}
 	}
 }
@@ -270,7 +266,7 @@ func swaggerSchemaFakeServer() (*httptest.Server, error) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		var resp interface{}
 		if request == 1 {
-			resp = metav1.APIVersions{Versions: []string{"v1", "v2", "v3"}}
+			resp = unversioned.APIVersions{Versions: []string{"v1", "v2", "v3"}}
 			request++
 		} else {
 			resp = swagger.ApiDeclaration{}
@@ -296,7 +292,7 @@ func TestGetSwaggerSchema(t *testing.T) {
 	}
 	defer server.Close()

-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
 	got, err := client.SwaggerSchema(v1.SchemeGroupVersion)
 	if err != nil {
 		t.Fatalf("unexpected encoding error: %v", err)
@@ -315,8 +311,8 @@ func TestGetSwaggerSchemaFail(t *testing.T) {
 	}
 	defer server.Close()

-	client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-	got, err := client.SwaggerSchema(schema.GroupVersion{Group: "api.group", Version: "v4"})
+	client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+	got, err := client.SwaggerSchema(unversioned.GroupVersion{Group: "api.group", Version: "v4"})
 	if got != nil {
 		t.Fatalf("unexpected response: %v", got)
 	}
@@ -326,21 +322,21 @@ func TestGetSwaggerSchemaFail(t *testing.T) {
 }

 func TestServerPreferredResources(t *testing.T) {
-	stable := metav1.APIResourceList{
+	stable := unversioned.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 			{Name: "services", Namespaced: true, Kind: "Service"},
 			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
 	tests := []struct {
-		resourcesList []*metav1.APIResourceList
+		resourcesList *unversioned.APIResourceList
 		response      func(w http.ResponseWriter, req *http.Request)
 		expectErr     func(err error) bool
 	}{
 		{
-			resourcesList: []*metav1.APIResourceList{&stable},
+			resourcesList: &stable,
 			expectErr:     IsGroupDiscoveryFailedError,
 			response: func(w http.ResponseWriter, req *http.Request) {
 				var list interface{}
@@ -351,16 +347,16 @@ func TestServerPreferredResources(t *testing.T) {
 				case "/api/v1":
 					list = &stable
 				case "/api":
-					list = &metav1.APIVersions{
+					list = &unversioned.APIVersions{
 						Versions: []string{
 							"v1",
 						},
 					}
 				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
+					list = &unversioned.APIGroupList{
+						Groups: []unversioned.APIGroup{
 							{
-								Versions: []metav1.GroupVersionForDiscovery{
+								Versions: []unversioned.GroupVersionForDiscovery{
 									{GroupVersion: "extensions/v1beta1"},
 								},
 							},
@@ -393,16 +389,16 @@ func TestServerPreferredResources(t *testing.T) {
 				case "/api/v1":
 					w.WriteHeader(http.StatusInternalServerError)
 				case "/api":
-					list = &metav1.APIVersions{
+					list = &unversioned.APIVersions{
 						Versions: []string{
 							"v1",
 						},
 					}
 				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
+					list = &unversioned.APIGroupList{
+						Groups: []unversioned.APIGroup{
 							{
-								Versions: []metav1.GroupVersionForDiscovery{
+								Versions: []unversioned.GroupVersionForDiscovery{
 									{GroupVersion: "extensions/v1beta1"},
 								},
 							},
@@ -428,8 +424,8 @@ func TestServerPreferredResources(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(test.response))
 		defer server.Close()

-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredResources()
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		got, err := client.ServerPreferredResources()
 		if test.expectErr != nil {
 			if err == nil {
 				t.Error("unexpected non-error")
@@ -441,13 +437,7 @@ func TestServerPreferredResources(t *testing.T) {
 			t.Errorf("unexpected error: %v", err)
 			continue
 		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-			continue
-		}
-		expected, _ := GroupVersionResources(test.resourcesList)
-		if !reflect.DeepEqual(got, expected) {
+		if !reflect.DeepEqual(got, test.resourcesList) {
 			t.Errorf("expected:\n%v\ngot:\n%v\n", test.resourcesList, got)
 		}
 		server.Close()
@@ -455,15 +445,15 @@ func TestServerPreferredResources(t *testing.T) {
 }

 func TestServerPreferredResourcesRetries(t *testing.T) {
-	stable := metav1.APIResourceList{
+	stable := unversioned.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 		},
 	}
-	beta := metav1.APIResourceList{
+	beta := unversioned.APIResourceList{
 		GroupVersion: "extensions/v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
 		},
 	}
@@ -483,20 +473,20 @@ func TestServerPreferredResourcesRetries(t *testing.T) {
 			case "/api/v1":
 				list = &stable
 			case "/api":
-				list = &metav1.APIVersions{
+				list = &unversioned.APIVersions{
 					Versions: []string{
 						"v1",
 					},
 				}
 			case "/apis":
-				list = &metav1.APIGroupList{
-					Groups: []metav1.APIGroup{
+				list = &unversioned.APIGroupList{
+					Groups: []unversioned.APIGroup{
 						{
 							Name: "extensions",
-							Versions: []metav1.GroupVersionForDiscovery{
+							Versions: []unversioned.GroupVersionForDiscovery{
 								{GroupVersion: "extensions/v1beta1"},
 							},
-							PreferredVersion: metav1.GroupVersionForDiscovery{
+							PreferredVersion: unversioned.GroupVersionForDiscovery{
 								GroupVersion: "extensions/v1beta1",
 								Version:      "v1beta1",
 							},
@@ -541,15 +531,11 @@ func TestServerPreferredResourcesRetries(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(response(tc.responseErrors)))
 		defer server.Close()

-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredResources()
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		got, err := client.ServerPreferredResources()
 		if !tc.expectedError(err) {
 			t.Errorf("case %d: unexpected error: %v", i, err)
 		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("case %d: unexpected error: %v", i, err)
-		}
 		if len(got) != tc.expectResources {
 			t.Errorf("case %d: expect %d resources, got %#v", i, tc.expectResources, got)
 		}
@@ -558,37 +544,37 @@ func TestServerPreferredResourcesRetries(t *testing.T) {
 }

 func TestServerPreferredNamespacedResources(t *testing.T) {
-	stable := metav1.APIResourceList{
+	stable := unversioned.APIResourceList{
 		GroupVersion: "v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "pods", Namespaced: true, Kind: "Pod"},
 			{Name: "services", Namespaced: true, Kind: "Service"},
 			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
-	batchv1 := metav1.APIResourceList{
+	batchv1 := unversioned.APIResourceList{
 		GroupVersion: "batch/v1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
-	batchv2alpha1 := metav1.APIResourceList{
+	batchv2alpha1 := unversioned.APIResourceList{
 		GroupVersion: "batch/v2alpha1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
 		},
 	}
-	batchv3alpha1 := metav1.APIResourceList{
+	batchv3alpha1 := unversioned.APIResourceList{
 		GroupVersion: "batch/v3alpha1",
-		APIResources: []metav1.APIResource{
+		APIResources: []unversioned.APIResource{
 			{Name: "jobs", Namespaced: true, Kind: "Job"},
 			{Name: "cronjobs", Namespaced: true, Kind: "CronJob"},
 		},
 	}
 	tests := []struct {
 		response func(w http.ResponseWriter, req *http.Request)
-		expected map[schema.GroupVersionResource]struct{}
+		expected []unversioned.GroupVersionResource
 	}{
 		{
 			response: func(w http.ResponseWriter, req *http.Request) {
@@ -597,7 +583,7 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				case "/api/v1":
 					list = &stable
 				case "/api":
-					list = &metav1.APIVersions{
+					list = &unversioned.APIVersions{
 						Versions: []string{
 							"v1",
 						},
@@ -616,9 +602,9 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				w.WriteHeader(http.StatusOK)
 				w.Write(output)
 			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}:     {},
-				schema.GroupVersionResource{Group: "", Version: "v1", Resource: "services"}: {},
+			expected: []unversioned.GroupVersionResource{
+				{Group: "", Version: "v1", Resource: "pods"},
+				{Group: "", Version: "v1", Resource: "services"},
 			},
 		},
 		{
@@ -626,16 +612,16 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				var list interface{}
 				switch req.URL.Path {
 				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
+					list = &unversioned.APIGroupList{
+						Groups: []unversioned.APIGroup{
 							{
 								Name: "batch",
-								Versions: []metav1.GroupVersionForDiscovery{
+								Versions: []unversioned.GroupVersionForDiscovery{
 									{GroupVersion: "batch/v1", Version: "v1"},
 									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
 									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
 								},
-								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v1", Version: "v1"},
+								PreferredVersion: unversioned.GroupVersionForDiscovery{GroupVersion: "batch/v1", Version: "v1"},
 							},
 						},
 					}
@@ -659,9 +645,9 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				w.WriteHeader(http.StatusOK)
 				w.Write(output)
 			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "batch", Version: "v1", Resource: "jobs"}:           {},
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
+			expected: []unversioned.GroupVersionResource{
+				{Group: "batch", Version: "v1", Resource: "jobs"},
+				{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"},
 			},
 		},
 		{
@@ -669,16 +655,16 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				var list interface{}
 				switch req.URL.Path {
 				case "/apis":
-					list = &metav1.APIGroupList{
-						Groups: []metav1.APIGroup{
+					list = &unversioned.APIGroupList{
+						Groups: []unversioned.APIGroup{
 							{
 								Name: "batch",
-								Versions: []metav1.GroupVersionForDiscovery{
+								Versions: []unversioned.GroupVersionForDiscovery{
 									{GroupVersion: "batch/v1", Version: "v1"},
 									{GroupVersion: "batch/v2alpha1", Version: "v2alpha1"},
 									{GroupVersion: "batch/v3alpha1", Version: "v3alpha1"},
 								},
-								PreferredVersion: metav1.GroupVersionForDiscovery{GroupVersion: "batch/v2alpha", Version: "v2alpha1"},
+								PreferredVersion: unversioned.GroupVersionForDiscovery{GroupVersion: "batch/v2alpha", Version: "v2alpha1"},
 							},
 						},
 					}
@@ -702,39 +688,27 @@ func TestServerPreferredNamespacedResources(t *testing.T) {
 				w.WriteHeader(http.StatusOK)
 				w.Write(output)
 			},
-			expected: map[schema.GroupVersionResource]struct{}{
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "jobs"}:     {},
-				schema.GroupVersionResource{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"}: {},
+			expected: []unversioned.GroupVersionResource{
+				{Group: "batch", Version: "v2alpha1", Resource: "jobs"},
+				{Group: "batch", Version: "v2alpha1", Resource: "cronjobs"},
 			},
 		},
 	}
-	for i, test := range tests {
+	for _, test := range tests {
 		server := httptest.NewServer(http.HandlerFunc(test.response))
 		defer server.Close()

-		client := NewDiscoveryClientForConfigOrDie(&restclient.Config{Host: server.URL})
-		resources, err := client.ServerPreferredNamespacedResources()
+		client := NewDiscoveryClientForConfigOrDie(&rest.Config{Host: server.URL})
+		got, err := client.ServerPreferredNamespacedResources()
 		if err != nil {
-			t.Errorf("[%d] unexpected error: %v", i, err)
+			t.Errorf("unexpected error: %v", err)
 			continue
 		}
-		got, err := GroupVersionResources(resources)
-		if err != nil {
-			t.Errorf("[%d] unexpected error: %v", i, err)
-			continue
-		}
-
+		// we need deterministic order and since during processing in ServerPreferredNamespacedResources
+		// a map comes into play the result needs sorting
 		if !reflect.DeepEqual(got, test.expected) {
-			t.Errorf("[%d] expected:\n%v\ngot:\n%v\n", i, test.expected, got)
+			t.Errorf("expected:\n%v\ngot:\n%v\n", test.expected, got)
 		}
 		server.Close()
 	}
 }
-
-func groupVersions(resources []*metav1.APIResourceList) []string {
-	result := []string{}
-	for _, resourceList := range resources {
-		result = append(result, resourceList.GroupVersion)
-	}
-	return result
-}
--- a/discovery/fake/discovery.go
+++ b/discovery/fake/discovery.go
@@ -17,16 +17,11 @@ limitations under the License.
 package fake

 import (
-	"fmt"
-
 	"github.com/emicklei/go-restful/swagger"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/version"
+	"k8s.io/client-go/pkg/api/unversioned"
 	"k8s.io/client-go/pkg/api/v1"
-	kubeversion "k8s.io/client-go/pkg/version"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 	"k8s.io/client-go/testing"
 )

@@ -34,64 +29,59 @@ type FakeDiscovery struct {
 	*testing.Fake
 }

-func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+func (c *FakeDiscovery) ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
-		Resource: schema.GroupVersionResource{Resource: "resource"},
+		Resource: unversioned.GroupVersionResource{Resource: "resource"},
 	}
 	c.Invokes(action, nil)
-	for _, resourceList := range c.Resources {
-		if resourceList.GroupVersion == groupVersion {
-			return resourceList, nil
-		}
-	}
-	return nil, fmt.Errorf("GroupVersion %q not found", groupVersion)
+	return c.Resources[groupVersion], nil
 }

-func (c *FakeDiscovery) ServerResources() ([]*metav1.APIResourceList, error) {
+func (c *FakeDiscovery) ServerResources() (map[string]*unversioned.APIResourceList, error) {
 	action := testing.ActionImpl{
 		Verb:     "get",
-		Resource: schema.GroupVersionResource{Resource: "resource"},
+		Resource: unversioned.GroupVersionResource{Resource: "resource"},
 	}
 	c.Invokes(action, nil)
 	return c.Resources, nil
 }

-func (c *FakeDiscovery) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+func (c *FakeDiscovery) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
 	return nil, nil
 }

-func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
+func (c *FakeDiscovery) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
 	return nil, nil
 }

-func (c *FakeDiscovery) ServerGroups() (*metav1.APIGroupList, error) {
+func (c *FakeDiscovery) ServerGroups() (*unversioned.APIGroupList, error) {
 	return nil, nil
 }

 func (c *FakeDiscovery) ServerVersion() (*version.Info, error) {
 	action := testing.ActionImpl{}
 	action.Verb = "get"
-	action.Resource = schema.GroupVersionResource{Resource: "version"}
+	action.Resource = unversioned.GroupVersionResource{Resource: "version"}

 	c.Invokes(action, nil)
-	versionInfo := kubeversion.Get()
+	versionInfo := version.Get()
 	return &versionInfo, nil
 }

-func (c *FakeDiscovery) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+func (c *FakeDiscovery) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
 	action := testing.ActionImpl{}
 	action.Verb = "get"
 	if version == v1.SchemeGroupVersion {
-		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
+		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/api/" + version.Version}
 	} else {
-		action.Resource = schema.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
+		action.Resource = unversioned.GroupVersionResource{Resource: "/swaggerapi/apis/" + version.Group + "/" + version.Version}
 	}

 	c.Invokes(action, nil)
 	return &swagger.ApiDeclaration{}, nil
 }

-func (c *FakeDiscovery) RESTClient() restclient.Interface {
+func (c *FakeDiscovery) RESTClient() rest.Interface {
 	return nil
 }
--- a/discovery/helper.go
+++ b/discovery/helper.go
@@ -19,23 +19,25 @@ package discovery
 import (
 	"fmt"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
-	apimachineryversion "k8s.io/apimachinery/pkg/version"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/util/sets"
+	"k8s.io/client-go/pkg/version"
+	// Import solely to initialize client auth plugins.
+	_ "k8s.io/client-go/plugin/pkg/client/auth"
 )

 // MatchesServerVersion queries the server to compares the build version
 // (git hash) of the client with the server's build version. It returns an error
 // if it failed to contact the server or if the versions are not an exact match.
-func MatchesServerVersion(clientVersion apimachineryversion.Info, client DiscoveryInterface) error {
+func MatchesServerVersion(client DiscoveryInterface) error {
+	cVer := version.Get()
 	sVer, err := client.ServerVersion()
 	if err != nil {
 		return fmt.Errorf("couldn't read version from server: %v\n", err)
 	}
 	// GitVersion includes GitCommit and GitTreeState, but best to be safe?
-	if clientVersion.GitVersion != sVer.GitVersion || clientVersion.GitCommit != sVer.GitCommit || clientVersion.GitTreeState != sVer.GitTreeState {
-		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, clientVersion)
+	if cVer.GitVersion != sVer.GitVersion || cVer.GitCommit != sVer.GitCommit || cVer.GitTreeState != sVer.GitTreeState {
+		return fmt.Errorf("server version (%#v) differs from client version (%#v)!\n", sVer, cVer)
 	}

 	return nil
@@ -47,10 +49,7 @@ func MatchesServerVersion(clientVersion apimachineryversion.Info, client Discove
 //   preference.
 // - If version is provided and the server does not support it,
 //   return an error.
-// TODO negotiation should be reserved for cases where we need a version for a given group.  In those cases, it should return an ordered list of
-// server preferences.  From that list, a separate function can match from an ordered list of client versions.
-// This is not what the function has ever done before, but it makes more logical sense.
-func NegotiateVersion(client DiscoveryInterface, requiredGV *schema.GroupVersion, clientRegisteredGVs []schema.GroupVersion) (*schema.GroupVersion, error) {
+func NegotiateVersion(client DiscoveryInterface, requiredGV *unversioned.GroupVersion, clientRegisteredGVs []unversioned.GroupVersion) (*unversioned.GroupVersion, error) {
 	clientVersions := sets.String{}
 	for _, gv := range clientRegisteredGVs {
 		clientVersions.Insert(gv.String())
@@ -61,7 +60,7 @@ func NegotiateVersion(client DiscoveryInterface, requiredGV *schema.GroupVersion
 		// not a negotiation specific error.
 		return nil, err
 	}
-	versions := metav1.ExtractGroupVersions(groups)
+	versions := unversioned.ExtractGroupVersions(groups)
 	serverVersions := sets.String{}
 	for _, v := range versions {
 		serverVersions.Insert(v)
@@ -105,58 +104,6 @@ func NegotiateVersion(client DiscoveryInterface, requiredGV *schema.GroupVersion
 		return &clientRegisteredGVs[0], nil
 	}

-	// fall back to an empty GroupVersion.  Most client commands no longer respect a GroupVersion anyway
-	return &schema.GroupVersion{}, nil
-}
-
-// GroupVersionResources converts APIResourceLists to the GroupVersionResources.
-func GroupVersionResources(rls []*metav1.APIResourceList) (map[schema.GroupVersionResource]struct{}, error) {
-	gvrs := map[schema.GroupVersionResource]struct{}{}
-	for _, rl := range rls {
-		gv, err := schema.ParseGroupVersion(rl.GroupVersion)
-		if err != nil {
-			return nil, err
-		}
-		for i := range rl.APIResources {
-			gvrs[schema.GroupVersionResource{Group: gv.Group, Version: gv.Version, Resource: rl.APIResources[i].Name}] = struct{}{}
-		}
-	}
-	return gvrs, nil
-}
-
-// FilteredBy filters by the given predicate. Empty APIResourceLists are dropped.
-func FilteredBy(pred ResourcePredicate, rls []*metav1.APIResourceList) []*metav1.APIResourceList {
-	result := []*metav1.APIResourceList{}
-	for _, rl := range rls {
-		filtered := *rl
-		filtered.APIResources = nil
-		for i := range rl.APIResources {
-			if pred.Match(rl.GroupVersion, &rl.APIResources[i]) {
-				filtered.APIResources = append(filtered.APIResources, rl.APIResources[i])
-			}
-		}
-		if filtered.APIResources != nil {
-			result = append(result, &filtered)
-		}
-	}
-	return result
-}
-
-type ResourcePredicate interface {
-	Match(groupVersion string, r *metav1.APIResource) bool
-}
-
-type ResourcePredicateFunc func(groupVersion string, r *metav1.APIResource) bool
-
-func (fn ResourcePredicateFunc) Match(groupVersion string, r *metav1.APIResource) bool {
-	return fn(groupVersion, r)
-}
-
-// SupportsAllVerbs is a predicate matching a resource iff all given verbs are supported.
-type SupportsAllVerbs struct {
-	Verbs []string
-}
-
-func (p SupportsAllVerbs) Match(groupVersion string, r *metav1.APIResource) bool {
-	return sets.NewString([]string(r.Verbs)...).HasAll(p.Verbs...)
+	return nil, fmt.Errorf("failed to negotiate an api version; server supports: %v, client supports: %v",
+		serverVersions, clientVersions)
 }
--- a/discovery/helper_blackbox_test.go
+++ b/discovery/helper_blackbox_test.go
@@ -26,17 +26,14 @@ import (
 	"strings"
 	"testing"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	uapi "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/api/testapi"
+	uapi "k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/apimachinery/registered"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"
-
-	_ "k8s.io/client-go/pkg/api/install"
 )

 func objBody(object interface{}) io.ReadCloser {
@@ -50,84 +47,83 @@ func objBody(object interface{}) io.ReadCloser {
 func TestNegotiateVersion(t *testing.T) {
 	tests := []struct {
 		name            string
-		requiredVersion *schema.GroupVersion
-		expectedVersion *schema.GroupVersion
+		requiredVersion *uapi.GroupVersion
+		expectedVersion *uapi.GroupVersion
 		serverVersions  []string
-		clientVersions  []schema.GroupVersion
+		clientVersions  []uapi.GroupVersion
 		expectErr       func(err error) bool
 		sendErr         error
 		statusCode      int
 	}{
 		{
 			name:            "server supports client default",
-			serverVersions:  []string{"version1", api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
+			serverVersions:  []string{"version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
 			statusCode:      http.StatusOK,
 		},
 		{
 			name:            "server falls back to client supported",
 			serverVersions:  []string{"version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
 			statusCode:      http.StatusOK,
 		},
 		{
 			name:            "explicit version supported",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
-			serverVersions:  []string{"/version1", api.Registry.GroupOrDie(api.GroupName).GroupVersion.String()},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "v1"},
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
+			serverVersions:  []string{"/version1", registered.GroupOrDie(api.GroupName).GroupVersion.String()},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "v1"},
 			statusCode:      http.StatusOK,
 		},
 		{
 			name:            "explicit version not supported on server",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
 			serverVersions:  []string{"version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
 			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `server does not support API version "v1"`) },
 			statusCode:      http.StatusOK,
 		},
 		{
 			name:            "explicit version not supported on client",
-			requiredVersion: &schema.GroupVersion{Version: "v1"},
+			requiredVersion: &uapi.GroupVersion{Version: "v1"},
 			serverVersions:  []string{"v1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}},
 			expectErr:       func(err error) bool { return strings.Contains(err.Error(), `client does not support API version "v1"`) },
 			statusCode:      http.StatusOK,
 		},
 		{
 			name:           "connection refused error",
 			serverVersions: []string{"version1"},
-			clientVersions: []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
+			clientVersions: []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
 			sendErr:        errors.New("connection refused"),
 			expectErr:      func(err error) bool { return strings.Contains(err.Error(), "connection refused") },
 			statusCode:     http.StatusOK,
 		},
 		{
 			name:            "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, use default GroupVersion",
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
 			statusCode:      http.StatusForbidden,
 		},
 		{
 			name:            "discovery fails due to 404 Not Found errors and thus serverVersions is empty, use requested GroupVersion",
-			requiredVersion: &schema.GroupVersion{Version: "version1"},
-			clientVersions:  []schema.GroupVersion{{Version: "version1"}, api.Registry.GroupOrDie(api.GroupName).GroupVersion},
-			expectedVersion: &schema.GroupVersion{Version: "version1"},
+			requiredVersion: &uapi.GroupVersion{Version: "version1"},
+			clientVersions:  []uapi.GroupVersion{{Version: "version1"}, registered.GroupOrDie(api.GroupName).GroupVersion},
+			expectedVersion: &uapi.GroupVersion{Version: "version1"},
 			statusCode:      http.StatusNotFound,
 		},
 		{
-			name:            "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, fallback to empty GroupVersion",
-			expectedVersion: &schema.GroupVersion{},
-			statusCode:      http.StatusForbidden,
+			name:       "discovery fails due to 403 Forbidden errors and thus serverVersions is empty, no fallback GroupVersion",
+			expectErr:  func(err error) bool { return strings.Contains(err.Error(), "failed to negotiate an api version;") },
+			statusCode: http.StatusForbidden,
 		},
 	}

 	for _, test := range tests {
 		fakeClient := &fake.RESTClient{
-			APIRegistry:          api.Registry,
-			NegotiatedSerializer: api.Codecs,
+			NegotiatedSerializer: testapi.Default.NegotiatedSerializer(),
 			Resp: &http.Response{
 				StatusCode: test.statusCode,
 				Body:       objBody(&uapi.APIVersions{Versions: test.serverVersions}),
@@ -141,8 +137,8 @@ func TestNegotiateVersion(t *testing.T) {
 				return &http.Response{StatusCode: test.statusCode, Header: header, Body: objBody(&uapi.APIVersions{Versions: test.serverVersions})}, nil
 			}),
 		}
-		c := discovery.NewDiscoveryClientForConfigOrDie(&restclient.Config{})
-		c.RESTClient().(*restclient.RESTClient).Client = fakeClient.Client
+		c := discovery.NewDiscoveryClientForConfigOrDie(&rest.Config{})
+		c.RESTClient().(*rest.RESTClient).Client = fakeClient.Client
 		response, err := discovery.NegotiateVersion(c, test.requiredVersion, test.clientVersions)
 		if err == nil && test.expectErr != nil {
 			t.Errorf("expected error, got nil for [%s].", test.name)
@@ -158,74 +154,3 @@ func TestNegotiateVersion(t *testing.T) {
 		}
 	}
 }
-
-func TestFilteredBy(t *testing.T) {
-	all := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return true
-	})
-	none := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return false
-	})
-	onlyV2 := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return strings.HasSuffix(gv, "/v2") || gv == "v2"
-	})
-	onlyBar := discovery.ResourcePredicateFunc(func(gv string, r *metav1.APIResource) bool {
-		return r.Kind == "Bar"
-	})
-
-	foo := []*metav1.APIResourceList{
-		{
-			GroupVersion: "foo/v1",
-			APIResources: []metav1.APIResource{
-				{Name: "bar", Kind: "Bar"},
-				{Name: "test", Kind: "Test"},
-			},
-		},
-		{
-			GroupVersion: "foo/v2",
-			APIResources: []metav1.APIResource{
-				{Name: "bar", Kind: "Bar"},
-				{Name: "test", Kind: "Test"},
-			},
-		},
-		{
-			GroupVersion: "foo/v3",
-			APIResources: []metav1.APIResource{},
-		},
-	}
-
-	tests := []struct {
-		input             []*metav1.APIResourceList
-		pred              discovery.ResourcePredicate
-		expectedResources []string
-	}{
-		{nil, all, []string{}},
-		{[]*metav1.APIResourceList{
-			{GroupVersion: "foo/v1"},
-		}, all, []string{}},
-		{foo, all, []string{"foo/v1.bar", "foo/v1.test", "foo/v2.bar", "foo/v2.test"}},
-		{foo, onlyV2, []string{"foo/v2.bar", "foo/v2.test"}},
-		{foo, onlyBar, []string{"foo/v1.bar", "foo/v2.bar"}},
-		{foo, none, []string{}},
-	}
-	for i, test := range tests {
-		filtered := discovery.FilteredBy(test.pred, test.input)
-
-		if expected, got := sets.NewString(test.expectedResources...), sets.NewString(stringify(filtered)...); !expected.Equal(got) {
-			t.Errorf("[%d] unexpected group versions: expected=%v, got=%v", i, test.expectedResources, stringify(filtered))
-		}
-	}
-}
-
-func stringify(rls []*metav1.APIResourceList) []string {
-	result := []string{}
-	for _, rl := range rls {
-		for _, r := range rl.APIResources {
-			result = append(result, rl.GroupVersion+"."+r.Name)
-		}
-		if len(rl.APIResources) == 0 {
-			result = append(result, rl.GroupVersion)
-		}
-	}
-	return result
-}
--- a/discovery/restmapper.go
+++ b/discovery/restmapper.go
@@ -20,10 +20,9 @@ import (
 	"fmt"
 	"sync"

-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"

 	"github.com/golang/glog"
 )
@@ -31,10 +30,10 @@ import (
 // APIGroupResources is an API group with a mapping of versions to
 // resources.
 type APIGroupResources struct {
-	Group metav1.APIGroup
+	Group unversioned.APIGroup
 	// A mapping of version string to a slice of APIResources for
 	// that version.
-	VersionedResources map[string][]metav1.APIResource
+	VersionedResources map[string][]unversioned.APIResource
 }

 // NewRESTMapper returns a PriorityRESTMapper based on the discovered
@@ -43,9 +42,8 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 	unionMapper := meta.MultiRESTMapper{}

 	var groupPriority []string
-	// /v1 is special.  It should always come first
-	resourcePriority := []schema.GroupVersionResource{{Group: "", Version: "v1", Resource: meta.AnyResource}}
-	kindPriority := []schema.GroupVersionKind{{Group: "", Version: "v1", Kind: meta.AnyKind}}
+	var resourcePriority []unversioned.GroupVersionResource
+	var kindPriority []unversioned.GroupVersionKind

 	for _, group := range groupResources {
 		groupPriority = append(groupPriority, group.Group.Name)
@@ -53,13 +51,13 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 		if len(group.Group.PreferredVersion.Version) != 0 {
 			preferred := group.Group.PreferredVersion.Version
 			if _, ok := group.VersionedResources[preferred]; ok {
-				resourcePriority = append(resourcePriority, schema.GroupVersionResource{
+				resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
 					Group:    group.Group.Name,
 					Version:  group.Group.PreferredVersion.Version,
 					Resource: meta.AnyResource,
 				})

-				kindPriority = append(kindPriority, schema.GroupVersionKind{
+				kindPriority = append(kindPriority, unversioned.GroupVersionKind{
 					Group:   group.Group.Name,
 					Version: group.Group.PreferredVersion.Version,
 					Kind:    meta.AnyKind,
@@ -73,8 +71,8 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 				continue
 			}

-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
-			versionMapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{gv}, versionInterfaces)
+			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			versionMapper := meta.NewDefaultRESTMapper([]unversioned.GroupVersion{gv}, versionInterfaces)

 			for _, resource := range resources {
 				scope := meta.RESTScopeNamespace
@@ -92,12 +90,12 @@ func NewRESTMapper(groupResources []*APIGroupResources, versionInterfaces meta.V
 	}

 	for _, group := range groupPriority {
-		resourcePriority = append(resourcePriority, schema.GroupVersionResource{
+		resourcePriority = append(resourcePriority, unversioned.GroupVersionResource{
 			Group:    group,
 			Version:  meta.AnyVersion,
 			Resource: meta.AnyResource,
 		})
-		kindPriority = append(kindPriority, schema.GroupVersionKind{
+		kindPriority = append(kindPriority, unversioned.GroupVersionKind{
 			Group:   group,
 			Version: meta.AnyVersion,
 			Kind:    meta.AnyKind,
@@ -122,7 +120,7 @@ func GetAPIGroupResources(cl DiscoveryInterface) ([]*APIGroupResources, error) {
 	for _, group := range apiGroups.Groups {
 		groupResources := &APIGroupResources{
 			Group:              group,
-			VersionedResources: make(map[string][]metav1.APIResource),
+			VersionedResources: make(map[string][]unversioned.APIResource),
 		}
 		for _, version := range group.Versions {
 			resources, err := cl.ServerResourcesForGroupVersion(version.GroupVersion)
@@ -190,10 +188,10 @@ func (d *DeferredDiscoveryRESTMapper) Reset() {

 // KindFor takes a partial resource and returns back the single match.
 // It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) KindFor(resource schema.GroupVersionResource) (gvk schema.GroupVersionKind, err error) {
+func (d *DeferredDiscoveryRESTMapper) KindFor(resource unversioned.GroupVersionResource) (gvk unversioned.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return schema.GroupVersionKind{}, err
+		return unversioned.GroupVersionKind{}, err
 	}
 	gvk, err = del.KindFor(resource)
 	if err != nil && !d.cl.Fresh() {
@@ -205,7 +203,7 @@ func (d *DeferredDiscoveryRESTMapper) KindFor(resource schema.GroupVersionResour

 // KindsFor takes a partial resource and returns back the list of
 // potential kinds in priority order.
-func (d *DeferredDiscoveryRESTMapper) KindsFor(resource schema.GroupVersionResource) (gvks []schema.GroupVersionKind, err error) {
+func (d *DeferredDiscoveryRESTMapper) KindsFor(resource unversioned.GroupVersionResource) (gvks []unversioned.GroupVersionKind, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
@@ -220,10 +218,10 @@ func (d *DeferredDiscoveryRESTMapper) KindsFor(resource schema.GroupVersionResou

 // ResourceFor takes a partial resource and returns back the single
 // match. It returns an error if there are multiple matches.
-func (d *DeferredDiscoveryRESTMapper) ResourceFor(input schema.GroupVersionResource) (gvr schema.GroupVersionResource, err error) {
+func (d *DeferredDiscoveryRESTMapper) ResourceFor(input unversioned.GroupVersionResource) (gvr unversioned.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
-		return schema.GroupVersionResource{}, err
+		return unversioned.GroupVersionResource{}, err
 	}
 	gvr, err = del.ResourceFor(input)
 	if err != nil && !d.cl.Fresh() {
@@ -235,7 +233,7 @@ func (d *DeferredDiscoveryRESTMapper) ResourceFor(input schema.GroupVersionResou

 // ResourcesFor takes a partial resource and returns back the list of
 // potential resource in priority order.
-func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input schema.GroupVersionResource) (gvrs []schema.GroupVersionResource, err error) {
+func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input unversioned.GroupVersionResource) (gvrs []unversioned.GroupVersionResource, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
@@ -250,7 +248,7 @@ func (d *DeferredDiscoveryRESTMapper) ResourcesFor(input schema.GroupVersionReso

 // RESTMapping identifies a preferred resource mapping for the
 // provided group kind.
-func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk unversioned.GroupKind, versions ...string) (m *meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
@@ -266,15 +264,15 @@ func (d *DeferredDiscoveryRESTMapper) RESTMapping(gk schema.GroupKind, versions
 // RESTMappings returns the RESTMappings for the provided group kind
 // in a rough internal preferred order. If no kind is found, it will
 // return a NoResourceMatchError.
-func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) (ms []*meta.RESTMapping, err error) {
+func (d *DeferredDiscoveryRESTMapper) RESTMappings(gk unversioned.GroupKind) (ms []*meta.RESTMapping, err error) {
 	del, err := d.getDelegate()
 	if err != nil {
 		return nil, err
 	}
-	ms, err = del.RESTMappings(gk, versions...)
+	ms, err = del.RESTMappings(gk)
 	if len(ms) == 0 && !d.cl.Fresh() {
 		d.Reset()
-		ms, err = d.RESTMappings(gk, versions...)
+		ms, err = d.RESTMappings(gk)
 	}
 	return
 }
--- a/discovery/restmapper_test.go
+++ b/discovery/restmapper_test.go
@@ -14,19 +14,17 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-package discovery_test
+package discovery

 import (
 	"reflect"
 	"testing"

-	"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"
-	. "k8s.io/client-go/discovery"
-	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/apimachinery/registered"
+	"k8s.io/client-go/pkg/version"
+	"k8s.io/client-go/rest"
 	"k8s.io/client-go/rest/fake"

 	"github.com/emicklei/go-restful/swagger"
@@ -36,29 +34,14 @@ import (
 func TestRESTMapper(t *testing.T) {
 	resources := []*APIGroupResources{
 		{
-			Group: metav1.APIGroup{
-				Name: "extensions",
-				Versions: []metav1.GroupVersionForDiscovery{
-					{Version: "v1beta"},
-				},
-				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1beta"},
-			},
-			VersionedResources: map[string][]metav1.APIResource{
-				"v1beta": {
-					{Name: "jobs", Namespaced: true, Kind: "Job"},
-					{Name: "pods", Namespaced: true, Kind: "Pod"},
-				},
-			},
-		},
-		{
-			Group: metav1.APIGroup{
-				Versions: []metav1.GroupVersionForDiscovery{
+			Group: unversioned.APIGroup{
+				Versions: []unversioned.GroupVersionForDiscovery{
 					{Version: "v1"},
 					{Version: "v2"},
 				},
-				PreferredVersion: metav1.GroupVersionForDiscovery{Version: "v1"},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1"},
 			},
-			VersionedResources: map[string][]metav1.APIResource{
+			VersionedResources: map[string][]unversioned.APIResource{
 				"v1": {
 					{Name: "pods", Namespaced: true, Kind: "Pod"},
 				},
@@ -67,57 +50,62 @@ func TestRESTMapper(t *testing.T) {
 				},
 			},
 		},
+		{
+			Group: unversioned.APIGroup{
+				Name: "extensions",
+				Versions: []unversioned.GroupVersionForDiscovery{
+					{Version: "v1beta"},
+				},
+				PreferredVersion: unversioned.GroupVersionForDiscovery{Version: "v1beta"},
+			},
+			VersionedResources: map[string][]unversioned.APIResource{
+				"v1beta": {
+					{Name: "jobs", Namespaced: true, Kind: "Job"},
+				},
+			},
+		},
 	}

 	restMapper := NewRESTMapper(resources, nil)

 	kindTCs := []struct {
-		input schema.GroupVersionResource
-		want  schema.GroupVersionKind
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionKind
 	}{
 		{
-			input: schema.GroupVersionResource{
-				Resource: "pods",
-			},
-			want: schema.GroupVersionKind{
-				Version: "v1",
-				Kind:    "Pod",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Version:  "v1",
 				Resource: "pods",
 			},
-			want: schema.GroupVersionKind{
+			want: unversioned.GroupVersionKind{
 				Version: "v1",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
-			want: schema.GroupVersionKind{
+			want: unversioned.GroupVersionKind{
 				Version: "v2",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: schema.GroupVersionKind{
+			want: unversioned.GroupVersionKind{
 				Version: "v1",
 				Kind:    "Pod",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Resource: "jobs",
 			},
-			want: schema.GroupVersionKind{
+			want: unversioned.GroupVersionKind{
 				Group:   "extensions",
 				Version: "v1beta",
 				Kind:    "Job",
@@ -138,52 +126,43 @@ func TestRESTMapper(t *testing.T) {
 	}

 	resourceTCs := []struct {
-		input schema.GroupVersionResource
-		want  schema.GroupVersionResource
+		input unversioned.GroupVersionResource
+		want  unversioned.GroupVersionResource
 	}{
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
+				Version:  "v1",
 				Resource: "pods",
 			},
-			want: schema.GroupVersionResource{
+			want: unversioned.GroupVersionResource{
 				Version:  "v1",
 				Resource: "pods",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-			want: schema.GroupVersionResource{
-				Version:  "v1",
-				Resource: "pods",
-			},
-		},
-		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
-			want: schema.GroupVersionResource{
+			want: unversioned.GroupVersionResource{
 				Version:  "v2",
 				Resource: "pods",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Resource: "pods",
 			},
-			want: schema.GroupVersionResource{
+			want: unversioned.GroupVersionResource{
 				Version:  "v1",
 				Resource: "pods",
 			},
 		},
 		{
-			input: schema.GroupVersionResource{
+			input: unversioned.GroupVersionResource{
 				Resource: "jobs",
 			},
-			want: schema.GroupVersionResource{
+			want: unversioned.GroupVersionResource{
 				Group:    "extensions",
 				Version:  "v1beta",
 				Resource: "jobs",
@@ -208,11 +187,11 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert := assert.New(t)

 	cdc := fakeCachedDiscoveryInterface{fresh: false}
-	m := NewDeferredDiscoveryRESTMapper(&cdc, api.Registry.InterfacesFor)
+	m := NewDeferredDiscoveryRESTMapper(&cdc, registered.InterfacesFor)
 	assert.False(cdc.fresh, "should NOT be fresh after instantiation")
 	assert.Zero(cdc.invalidateCalls, "should not have called Invalidate()")

-	gvk, err := m.KindFor(schema.GroupVersionResource{
+	gvk, err := m.KindFor(unversioned.GroupVersionResource{
 		Group:    "a",
 		Version:  "v1",
 		Resource: "foo",
@@ -222,7 +201,7 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert.Equal(cdc.invalidateCalls, 1, "should have called Invalidate() once")
 	assert.Equal(gvk.Kind, "Foo")

-	gvk, err = m.KindFor(schema.GroupVersionResource{
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
 		Group:    "a",
 		Version:  "v1",
 		Resource: "foo",
@@ -230,7 +209,7 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert.NoError(err)
 	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again")

-	gvk, err = m.KindFor(schema.GroupVersionResource{
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
 		Group:    "a",
 		Version:  "v1",
 		Resource: "bar",
@@ -239,7 +218,7 @@ func TestDeferredDiscoveryRESTMapper_CacheMiss(t *testing.T) {
 	assert.Equal(cdc.invalidateCalls, 1, "should NOT have called Invalidate() again after another cache-miss, but with fresh==true")

 	cdc.fresh = false
-	gvk, err = m.KindFor(schema.GroupVersionResource{
+	gvk, err = m.KindFor(unversioned.GroupVersionResource{
 		Group:    "a",
 		Version:  "v1",
 		Resource: "bar",
@@ -266,23 +245,23 @@ func (c *fakeCachedDiscoveryInterface) Invalidate() {
 	c.enabledA = true
 }

-func (c *fakeCachedDiscoveryInterface) RESTClient() restclient.Interface {
+func (c *fakeCachedDiscoveryInterface) RESTClient() rest.Interface {
 	return &fake.RESTClient{}
 }

-func (c *fakeCachedDiscoveryInterface) ServerGroups() (*metav1.APIGroupList, error) {
+func (c *fakeCachedDiscoveryInterface) ServerGroups() (*unversioned.APIGroupList, error) {
 	if c.enabledA {
-		return &metav1.APIGroupList{
-			Groups: []metav1.APIGroup{
+		return &unversioned.APIGroupList{
+			Groups: []unversioned.APIGroup{
 				{
 					Name: "a",
-					Versions: []metav1.GroupVersionForDiscovery{
+					Versions: []unversioned.GroupVersionForDiscovery{
 						{
 							GroupVersion: "a/v1",
 							Version:      "v1",
 						},
 					},
-					PreferredVersion: metav1.GroupVersionForDiscovery{
+					PreferredVersion: unversioned.GroupVersionForDiscovery{
 						GroupVersion: "a/v1",
 						Version:      "v1",
 					},
@@ -290,14 +269,14 @@ func (c *fakeCachedDiscoveryInterface) ServerGroups() (*metav1.APIGroupList, err
 			},
 		}, nil
 	}
-	return &metav1.APIGroupList{}, nil
+	return &unversioned.APIGroupList{}, nil
 }

-func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*metav1.APIResourceList, error) {
+func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersion string) (*unversioned.APIResourceList, error) {
 	if c.enabledA && groupVersion == "a/v1" {
-		return &metav1.APIResourceList{
+		return &unversioned.APIResourceList{
 			GroupVersion: "a/v1",
-			APIResources: []metav1.APIResource{
+			APIResources: []unversioned.APIResource{
 				{
 					Name:       "foo",
 					Kind:       "Foo",
@@ -307,43 +286,40 @@ func (c *fakeCachedDiscoveryInterface) ServerResourcesForGroupVersion(groupVersi
 		}, nil
 	}

-	return nil, errors.NewNotFound(schema.GroupResource{}, "")
+	return nil, errors.NewNotFound(unversioned.GroupResource{}, "")
 }

-func (c *fakeCachedDiscoveryInterface) ServerResources() ([]*metav1.APIResourceList, error) {
+func (c *fakeCachedDiscoveryInterface) ServerResources() (map[string]*unversioned.APIResourceList, error) {
 	if c.enabledA {
 		av1, _ := c.ServerResourcesForGroupVersion("a/v1")
-		return []*metav1.APIResourceList{av1}, nil
+		return map[string]*unversioned.APIResourceList{
+			"a/v1": av1,
+		}, nil
 	}
-	return []*metav1.APIResourceList{}, nil
+	return map[string]*unversioned.APIResourceList{}, nil
 }

-func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]*metav1.APIResourceList, error) {
+func (c *fakeCachedDiscoveryInterface) ServerPreferredResources() ([]unversioned.GroupVersionResource, error) {
 	if c.enabledA {
-		return []*metav1.APIResourceList{
+		return []unversioned.GroupVersionResource{
 			{
-				GroupVersion: "a/v1",
-				APIResources: []metav1.APIResource{
-					{
-						Name:  "foo",
-						Kind:  "Foo",
-						Verbs: []string{},
-					},
-				},
+				Group:    "a",
+				Version:  "v1",
+				Resource: "foo",
 			},
 		}, nil
 	}
-	return nil, nil
+	return []unversioned.GroupVersionResource{}, nil
 }

-func (c *fakeCachedDiscoveryInterface) ServerPreferredNamespacedResources() ([]*metav1.APIResourceList, error) {
-	return nil, nil
+func (c *fakeCachedDiscoveryInterface) ServerPreferredNamespacedResources() ([]unversioned.GroupVersionResource, error) {
+	return []unversioned.GroupVersionResource{}, nil
 }

 func (c *fakeCachedDiscoveryInterface) ServerVersion() (*version.Info, error) {
 	return &version.Info{}, nil
 }

-func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version schema.GroupVersion) (*swagger.ApiDeclaration, error) {
+func (c *fakeCachedDiscoveryInterface) SwaggerSchema(version unversioned.GroupVersion) (*swagger.ApiDeclaration, error) {
 	return &swagger.ApiDeclaration{}, nil
 }
--- a/discovery/unstructured.go
+++ b/discovery/unstructured.go
@@ -19,20 +19,20 @@ package discovery
 import (
 	"fmt"

-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/runtime"
 )

 // UnstructuredObjectTyper provides a runtime.ObjectTyper implmentation for
 // runtime.Unstructured object based on discovery information.
 type UnstructuredObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
+	registered map[unversioned.GroupVersionKind]bool
 }

 // NewUnstructuredObjectTyper returns a runtime.ObjectTyper for
 // unstructred objects based on discovery information.
 func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *UnstructuredObjectTyper {
-	dot := &UnstructuredObjectTyper{registered: make(map[schema.GroupVersionKind]bool)}
+	dot := &UnstructuredObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
 	for _, group := range groupResources {
 		for _, discoveryVersion := range group.Group.Versions {
 			resources, ok := group.VersionedResources[discoveryVersion.Version]
@@ -40,7 +40,7 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 				continue
 			}

-			gv := schema.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
+			gv := unversioned.GroupVersion{Group: group.Group.Name, Version: discoveryVersion.Version}
 			for _, resource := range resources {
 				dot.registered[gv.WithKind(resource.Kind)] = true
 			}
@@ -50,39 +50,39 @@ func NewUnstructuredObjectTyper(groupResources []*APIGroupResources) *Unstructur
 }

 // ObjectKind returns the group,version,kind of the provided object, or an error
-// if the object in not runtime.Unstructured or has no group,version,kind
+// if the object in not *runtime.Unstructured or has no group,version,kind
 // information.
-func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (schema.GroupVersionKind, error) {
-	if _, ok := obj.(runtime.Unstructured); !ok {
-		return schema.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
+func (d *UnstructuredObjectTyper) ObjectKind(obj runtime.Object) (unversioned.GroupVersionKind, error) {
+	if _, ok := obj.(*runtime.Unstructured); !ok {
+		return unversioned.GroupVersionKind{}, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}

 	return obj.GetObjectKind().GroupVersionKind(), 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 runtime.Unstructured or
+// provided object, or an error if the object is not *runtime.Unstructured or
 // has no group,version,kind information. unversionedType will always be false
 // because runtime.Unstructured object should always have group,version,kind
 // information set.
-func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) {
+func (d *UnstructuredObjectTyper) ObjectKinds(obj runtime.Object) (gvks []unversioned.GroupVersionKind, unversionedType bool, err error) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {
 		return nil, false, err
 	}

-	return []schema.GroupVersionKind{gvk}, false, nil
+	return []unversioned.GroupVersionKind{gvk}, false, nil
 }

 // Recognizes returns true if the provided group,version,kind was in the
 // discovery information.
-func (d *UnstructuredObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
+func (d *UnstructuredObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
 	return d.registered[gvk]
 }

-// IsUnversioned returns false always because runtime.Unstructured objects
+// IsUnversioned returns false always because *runtime.Unstructured objects
 // should always have group,version,kind information set. ok will be true if the
-// object's group,version,kind is api.Registry.
+// object's group,version,kind is registered.
 func (d *UnstructuredObjectTyper) IsUnversioned(obj runtime.Object) (unversioned bool, ok bool) {
 	gvk, err := d.ObjectKind(obj)
 	if err != nil {
--- a/dynamic/client.go
+++ b/dynamic/client.go
@@ -26,30 +26,27 @@ import (
 	"net/url"
 	"strings"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/conversion/queryparams"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/unversioned"
 	"k8s.io/client-go/pkg/api/v1"
-	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/util/flowcontrol"
+	"k8s.io/client-go/pkg/conversion/queryparams"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer"
+	"k8s.io/client-go/pkg/util/flowcontrol"
+	"k8s.io/client-go/pkg/watch"
+	"k8s.io/client-go/rest"
 )

 // Client is a Kubernetes client that allows you to access metadata
 // and manipulate metadata of a Kubernetes API group.
 type Client struct {
-	cl             *restclient.RESTClient
+	cl             *rest.RESTClient
 	parameterCodec runtime.ParameterCodec
 }

 // 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) (*Client, error) {
+func NewClient(conf *rest.Config) (*Client, error) {
 	// avoid changing the original config
 	confCopy := *conf
 	conf = &confCopy
@@ -66,10 +63,10 @@ func NewClient(conf *restclient.Config) (*Client, error) {
 	}

 	if len(conf.UserAgent) == 0 {
-		conf.UserAgent = restclient.DefaultKubernetesUserAgent()
+		conf.UserAgent = rest.DefaultKubernetesUserAgent()
 	}

-	cl, err := restclient.RESTClientFor(conf)
+	cl, err := rest.RESTClientFor(conf)
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +82,7 @@ func (c *Client) GetRateLimiter() flowcontrol.RateLimiter {
 // 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 c.
-func (c *Client) Resource(resource *metav1.APIResource, namespace string) *ResourceClient {
+func (c *Client) Resource(resource *unversioned.APIResource, namespace string) *ResourceClient {
 	return &ResourceClient{
 		cl:             c.cl,
 		resource:       resource,
@@ -105,14 +102,14 @@ func (c *Client) ParameterCodec(parameterCodec runtime.ParameterCodec) *Client {
 // ResourceClient is an API interface to a specific resource under a
 // dynamic client.
 type ResourceClient struct {
-	cl             *restclient.RESTClient
-	resource       *metav1.APIResource
+	cl             *rest.RESTClient
+	resource       *unversioned.APIResource
 	ns             string
 	parameterCodec runtime.ParameterCodec
 }

 // List returns a list of objects for this resource.
-func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error) {
+func (rc *ResourceClient) List(opts runtime.Object) (runtime.Object, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -120,14 +117,14 @@ func (rc *ResourceClient) List(opts metav1.ListOptions) (runtime.Object, error)
 	return rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&opts, parameterEncoder).
+		VersionedParams(opts, parameterEncoder).
 		Do().
 		Get()
 }

 // Get gets the resource with the specified name.
-func (rc *ResourceClient) Get(name string) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Get(name string) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Get().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -138,7 +135,7 @@ func (rc *ResourceClient) Get(name string) (*unstructured.Unstructured, error) {
 }

 // Delete deletes the resource with the specified name.
-func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error {
+func (rc *ResourceClient) Delete(name string, opts *v1.DeleteOptions) error {
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -149,7 +146,7 @@ func (rc *ResourceClient) Delete(name string, opts *metav1.DeleteOptions) error
 }

 // DeleteCollection deletes a collection of objects.
-func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions, listOptions metav1.ListOptions) error {
+func (rc *ResourceClient) DeleteCollection(deleteOptions *v1.DeleteOptions, listOptions runtime.Object) error {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
@@ -157,15 +154,15 @@ func (rc *ResourceClient) DeleteCollection(deleteOptions *metav1.DeleteOptions,
 	return rc.cl.Delete().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&listOptions, parameterEncoder).
+		VersionedParams(listOptions, parameterEncoder).
 		Body(deleteOptions).
 		Do().
 		Error()
 }

 // Create creates the provided resource.
-func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Create(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Post().
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -176,8 +173,8 @@ func (rc *ResourceClient) Create(obj *unstructured.Unstructured) (*unstructured.
 }

 // Update updates the provided resource.
-func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Update(obj *runtime.Unstructured) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	if len(obj.GetName()) == 0 {
 		return result, errors.New("object missing name")
 	}
@@ -192,21 +189,21 @@ func (rc *ResourceClient) Update(obj *unstructured.Unstructured) (*unstructured.
 }

 // Watch returns a watch.Interface that watches the resource.
-func (rc *ResourceClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
+func (rc *ResourceClient) Watch(opts runtime.Object) (watch.Interface, error) {
 	parameterEncoder := rc.parameterCodec
 	if parameterEncoder == nil {
 		parameterEncoder = defaultParameterEncoder
 	}
-	opts.Watch = true
 	return rc.cl.Get().
+		Prefix("watch").
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
-		VersionedParams(&opts, parameterEncoder).
+		VersionedParams(opts, parameterEncoder).
 		Watch()
 }

-func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*unstructured.Unstructured, error) {
-	result := new(unstructured.Unstructured)
+func (rc *ResourceClient) Patch(name string, pt api.PatchType, data []byte) (*runtime.Unstructured, error) {
+	result := new(runtime.Unstructured)
 	err := rc.cl.Patch(pt).
 		NamespaceIfScoped(rc.ns, rc.resource.Namespaced).
 		Resource(rc.resource.Name).
@@ -221,14 +218,14 @@ func (rc *ResourceClient) Patch(name string, pt types.PatchType, data []byte) (*
 // with special handling for Status objects.
 type dynamicCodec struct{}

-func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
-	obj, gvk, err := unstructured.UnstructuredJSONScheme.Decode(data, gvk, obj)
+func (dynamicCodec) Decode(data []byte, gvk *unversioned.GroupVersionKind, obj runtime.Object) (runtime.Object, *unversioned.GroupVersionKind, error) {
+	obj, gvk, err := runtime.UnstructuredJSONScheme.Decode(data, gvk, obj)
 	if err != nil {
 		return nil, nil, err
 	}

-	if _, ok := obj.(*metav1.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
-		obj = &metav1.Status{}
+	if _, ok := obj.(*unversioned.Status); !ok && strings.ToLower(gvk.Kind) == "status" {
+		obj = &unversioned.Status{}
 		err := json.Unmarshal(data, obj)
 		if err != nil {
 			return nil, nil, err
@@ -239,11 +236,11 @@ func (dynamicCodec) Decode(data []byte, gvk *schema.GroupVersionKind, obj runtim
 }

 func (dynamicCodec) Encode(obj runtime.Object, w io.Writer) error {
-	return unstructured.UnstructuredJSONScheme.Encode(obj, w)
+	return runtime.UnstructuredJSONScheme.Encode(obj, w)
 }

-// ContentConfig returns a restclient.ContentConfig for dynamic types.
-func ContentConfig() restclient.ContentConfig {
+// ContentConfig returns a rest.ContentConfig for dynamic types.
+func ContentConfig() rest.ContentConfig {
 	var jsonInfo runtime.SerializerInfo
 	// TODO: api.Codecs here should become "pkg/apis/server/scheme" which is the minimal core you need
 	// to talk to a kubernetes server
@@ -256,7 +253,7 @@ func ContentConfig() restclient.ContentConfig {

 	jsonInfo.Serializer = dynamicCodec{}
 	jsonInfo.PrettySerializer = nil
-	return restclient.ContentConfig{
+	return rest.ContentConfig{
 		AcceptContentTypes:   runtime.ContentTypeJSON,
 		ContentType:          runtime.ContentTypeJSON,
 		NegotiatedSerializer: serializer.NegotiatedSerializerWrapper(jsonInfo),
@@ -267,11 +264,11 @@ func ContentConfig() restclient.ContentConfig {
 // parameters without trying to convert to the target version.
 type parameterCodec struct{}

-func (parameterCodec) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+func (parameterCodec) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
 	return queryparams.Convert(obj)
 }

-func (parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+func (parameterCodec) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on dynamic parameterCodec")
 }

@@ -279,7 +276,7 @@ var defaultParameterEncoder runtime.ParameterCodec = parameterCodec{}

 type versionedParameterEncoderWithV1Fallback struct{}

-func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
+func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Object, to unversioned.GroupVersion) (url.Values, error) {
 	ret, err := api.ParameterCodec.EncodeParameters(obj, to)
 	if err != nil && runtime.IsNotRegisteredError(err) {
 		// fallback to v1
@@ -288,7 +285,7 @@ func (versionedParameterEncoderWithV1Fallback) EncodeParameters(obj runtime.Obje
 	return ret, err
 }

-func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
+func (versionedParameterEncoderWithV1Fallback) DecodeParameters(parameters url.Values, from unversioned.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on versionedParameterEncoderWithV1Fallback")
 }

--- a/dynamic/client_pool.go
+++ b/dynamic/client_pool.go
@@ -19,28 +19,27 @@ package dynamic
 import (
 	"sync"

-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/pkg/api"
-	restclient "k8s.io/client-go/rest"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/rest"
 )

 // ClientPool manages a pool of dynamic clients.
 type ClientPool interface {
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionResource.
 	// Resource may be empty.
-	ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error)
+	ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error)
 	// ClientForGroupVersionKind returns a client configured for the specified groupVersionKind.
 	// Kind may be empty.
-	ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error)
+	ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error)
 }

 // APIPathResolverFunc knows how to convert a groupVersion to its API path. The Kind field is
 // optional.
-type APIPathResolverFunc func(kind schema.GroupVersionKind) string
+type APIPathResolverFunc func(kind unversioned.GroupVersionKind) string

 // LegacyAPIPathResolverFunc can resolve paths properly with the legacy API.
-func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
+func LegacyAPIPathResolverFunc(kind unversioned.GroupVersionKind) string {
 	if len(kind.Group) == 0 {
 		return "/api"
 	}
@@ -51,8 +50,8 @@ func LegacyAPIPathResolverFunc(kind schema.GroupVersionKind) string {
 // is asked to retrieve. This type is thread safe.
 type clientPoolImpl struct {
 	lock                sync.RWMutex
-	config              *restclient.Config
-	clients             map[schema.GroupVersion]*Client
+	config              *rest.Config
+	clients             map[unversioned.GroupVersion]*Client
 	apiPathResolverFunc APIPathResolverFunc
 	mapper              meta.RESTMapper
 }
@@ -60,31 +59,24 @@ type clientPoolImpl struct {
 // NewClientPool returns a ClientPool from the specified config. It reuses clients for the the same
 // group version. It is expected this type may be wrapped by specific logic that special cases certain
 // resources or groups.
-func NewClientPool(config *restclient.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
+func NewClientPool(config *rest.Config, mapper meta.RESTMapper, apiPathResolverFunc APIPathResolverFunc) ClientPool {
 	confCopy := *config

 	return &clientPoolImpl{
 		config:              &confCopy,
-		clients:             map[schema.GroupVersion]*Client{},
+		clients:             map[unversioned.GroupVersion]*Client{},
 		apiPathResolverFunc: apiPathResolverFunc,
 		mapper:              mapper,
 	}
 }

-// Instantiates a new dynamic client pool with the given config.
-func NewDynamicClientPool(cfg *restclient.Config) ClientPool {
-	// TODO: should use a dynamic RESTMapper built from the discovery results.
-	restMapper := api.Registry.RESTMapper()
-	return NewClientPool(cfg, restMapper, LegacyAPIPathResolverFunc)
-}
-
 // ClientForGroupVersionResource uses the provided RESTMapper to identify the appropriate resource. Resource may
 // be empty. If no matching kind is found the underlying client for that group is still returned.
-func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVersionResource) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionResource(resource unversioned.GroupVersionResource) (*Client, error) {
 	kinds, err := c.mapper.KindsFor(resource)
 	if err != nil {
 		if meta.IsNoMatchError(err) {
-			return c.ClientForGroupVersionKind(schema.GroupVersionKind{Group: resource.Group, Version: resource.Version})
+			return c.ClientForGroupVersionKind(unversioned.GroupVersionKind{Group: resource.Group, Version: resource.Version})
 		}
 		return nil, err
 	}
@@ -93,7 +85,7 @@ func (c *clientPoolImpl) ClientForGroupVersionResource(resource schema.GroupVers

 // ClientForGroupVersion returns a client for the specified groupVersion, creates one if none exists. Kind
 // in the GroupVersionKind may be empty.
-func (c *clientPoolImpl) ClientForGroupVersionKind(kind schema.GroupVersionKind) (*Client, error) {
+func (c *clientPoolImpl) ClientForGroupVersionKind(kind unversioned.GroupVersionKind) (*Client, error) {
 	c.lock.Lock()
 	defer c.lock.Unlock()

--- a/dynamic/client_test.go
+++ b/dynamic/client_test.go
@@ -25,15 +25,14 @@ import (
 	"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"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer/streaming"
+	"k8s.io/client-go/pkg/watch"
+	"k8s.io/client-go/pkg/watch/versioned"
+	"k8s.io/client-go/rest"
 )

 func getJSON(version, kind, name string) []byte {
@@ -46,8 +45,8 @@ func getListJSON(version, kind string, items ...[]byte) []byte {
 	return []byte(json)
 }

-func getObject(version, kind, name string) *unstructured.Unstructured {
-	return &unstructured.Unstructured{
+func getObject(version, kind, name string) *runtime.Unstructured {
+	return &runtime.Unstructured{
 		Object: map[string]interface{}{
 			"apiVersion": version,
 			"kind":       kind,
@@ -58,11 +57,11 @@ func getObject(version, kind, name string) *unstructured.Unstructured {
 	}
 }

-func getClientServer(gv *schema.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
+func getClientServer(gv *unversioned.GroupVersion, h func(http.ResponseWriter, *http.Request)) (*Client, *httptest.Server, error) {
 	srv := httptest.NewServer(http.HandlerFunc(h))
-	cl, err := NewClient(&restclient.Config{
+	cl, err := NewClient(&rest.Config{
 		Host:          srv.URL,
-		ContentConfig: restclient.ContentConfig{GroupVersion: gv},
+		ContentConfig: rest.ContentConfig{GroupVersion: gv},
 	})
 	if err != nil {
 		srv.Close()
@@ -77,7 +76,7 @@ func TestList(t *testing.T) {
 		namespace string
 		path      string
 		resp      []byte
-		want      *unstructured.UnstructuredList
+		want      *runtime.UnstructuredList
 	}{
 		{
 			name: "normal_list",
@@ -85,12 +84,12 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &unstructured.UnstructuredList{
+			want: &runtime.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*unstructured.Unstructured{
+				Items: []*runtime.Unstructured{
 					getObject("vTest", "rTest", "item1"),
 					getObject("vTest", "rTest", "item2"),
 				},
@@ -103,12 +102,12 @@ func TestList(t *testing.T) {
 			resp: getListJSON("vTest", "rTestList",
 				getJSON("vTest", "rTest", "item1"),
 				getJSON("vTest", "rTest", "item2")),
-			want: &unstructured.UnstructuredList{
+			want: &runtime.UnstructuredList{
 				Object: map[string]interface{}{
 					"apiVersion": "vTest",
 					"kind":       "rTestList",
 				},
-				Items: []*unstructured.Unstructured{
+				Items: []*runtime.Unstructured{
 					getObject("vTest", "rTest", "item1"),
 					getObject("vTest", "rTest", "item2"),
 				},
@@ -116,8 +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}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.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)
@@ -136,7 +135,7 @@ func TestList(t *testing.T) {
 		}
 		defer srv.Close()

-		got, err := cl.Resource(resource, tc.namespace).List(metav1.ListOptions{})
+		got, err := cl.Resource(resource, tc.namespace).List(&v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when listing %q: %v", tc.name, err)
 			continue
@@ -154,7 +153,7 @@ func TestGet(t *testing.T) {
 		name      string
 		path      string
 		resp      []byte
-		want      *unstructured.Unstructured
+		want      *runtime.Unstructured
 	}{
 		{
 			name: "normal_get",
@@ -171,8 +170,8 @@ func TestGet(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.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("Get(%q) got HTTP method %s. wanted GET", tc.name, r.Method)
@@ -204,9 +203,9 @@ func TestGet(t *testing.T) {
 }

 func TestDelete(t *testing.T) {
-	statusOK := &metav1.Status{
-		TypeMeta: metav1.TypeMeta{Kind: "Status"},
-		Status:   metav1.StatusSuccess,
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -224,8 +223,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}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.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)
@@ -236,7 +235,7 @@ func TestDelete(t *testing.T) {
 			}

 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -253,9 +252,9 @@ func TestDelete(t *testing.T) {
 }

 func TestDeleteCollection(t *testing.T) {
-	statusOK := &metav1.Status{
-		TypeMeta: metav1.TypeMeta{Kind: "Status"},
-		Status:   metav1.StatusSuccess,
+	statusOK := &unversioned.Status{
+		TypeMeta: unversioned.TypeMeta{Kind: "Status"},
+		Status:   unversioned.StatusSuccess,
 	}
 	tcs := []struct {
 		namespace string
@@ -273,8 +272,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}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.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)
@@ -285,7 +284,7 @@ func TestDeleteCollection(t *testing.T) {
 			}

 			w.Header().Set("Content-Type", runtime.ContentTypeJSON)
-			unstructured.UnstructuredJSONScheme.Encode(statusOK, w)
+			runtime.UnstructuredJSONScheme.Encode(statusOK, w)
 		})
 		if err != nil {
 			t.Errorf("unexpected error when creating client: %v", err)
@@ -293,7 +292,7 @@ func TestDeleteCollection(t *testing.T) {
 		}
 		defer srv.Close()

-		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, metav1.ListOptions{})
+		err = cl.Resource(resource, tc.namespace).DeleteCollection(nil, &v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when deleting collection %q: %v", tc.name, err)
 			continue
@@ -305,7 +304,7 @@ func TestCreate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *unstructured.Unstructured
+		obj       *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -321,8 +320,8 @@ func TestCreate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", 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)
@@ -364,7 +363,7 @@ func TestUpdate(t *testing.T) {
 	tcs := []struct {
 		name      string
 		namespace string
-		obj       *unstructured.Unstructured
+		obj       *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -380,8 +379,8 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", 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)
@@ -425,12 +424,10 @@ func TestWatch(t *testing.T) {
 		namespace string
 		events    []watch.Event
 		path      string
-		query     string
 	}{
 		{
-			name:  "normal_watch",
-			path:  "/api/gtest/vtest/rtest",
-			query: "watch=true",
+			name: "normal_watch",
+			path: "/api/gtest/vtest/watch/rtest",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "normal_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "normal_watch")},
@@ -440,8 +437,7 @@ func TestWatch(t *testing.T) {
 		{
 			name:      "namespaced_watch",
 			namespace: "nstest",
-			path:      "/api/gtest/vtest/namespaces/nstest/rtest",
-			query:     "watch=true",
+			path:      "/api/gtest/vtest/watch/namespaces/nstest/rtest",
 			events: []watch.Event{
 				{Type: watch.Added, Object: getObject("vTest", "rTest", "namespaced_watch")},
 				{Type: watch.Modified, Object: getObject("vTest", "rTest", "namespaced_watch")},
@@ -450,8 +446,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}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.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)
@@ -460,11 +456,8 @@ func TestWatch(t *testing.T) {
 			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{})
+			enc := versioned.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}
@@ -475,7 +468,7 @@ func TestWatch(t *testing.T) {
 		}
 		defer srv.Close()

-		watcher, err := cl.Resource(resource, tc.namespace).Watch(metav1.ListOptions{})
+		watcher, err := cl.Resource(resource, tc.namespace).Watch(&v1.ListOptions{})
 		if err != nil {
 			t.Errorf("unexpected error when watching %q: %v", tc.name, err)
 			continue
@@ -495,7 +488,7 @@ func TestPatch(t *testing.T) {
 		name      string
 		namespace string
 		patch     []byte
-		want      *unstructured.Unstructured
+		want      *runtime.Unstructured
 		path      string
 	}{
 		{
@@ -513,8 +506,8 @@ func TestPatch(t *testing.T) {
 		},
 	}
 	for _, tc := range tcs {
-		gv := &schema.GroupVersion{Group: "gtest", Version: "vtest"}
-		resource := &metav1.APIResource{Name: "rtest", Namespaced: len(tc.namespace) != 0}
+		gv := &unversioned.GroupVersion{Group: "gtest", Version: "vtest"}
+		resource := &unversioned.APIResource{Name: "rtest", 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)
@@ -525,8 +518,8 @@ func TestPatch(t *testing.T) {
 			}

 			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)
+			if content != string(api.StrategicMergePatchType) {
+				t.Errorf("Patch(%q) got Content-Type %s. wanted %s", tc.name, content, api.StrategicMergePatchType)
 			}

 			data, err := ioutil.ReadAll(r.Body)
@@ -545,7 +538,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, tc.namespace).Patch(tc.name, api.StrategicMergePatchType, tc.patch)
 		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
@@ -19,27 +19,25 @@ 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"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/runtime"
 )

 // VersionInterfaces provides an object converter and metadata
 // accessor appropriate for use with unstructured objects.
-func VersionInterfaces(schema.GroupVersion) (*meta.VersionInterfaces, error) {
+func VersionInterfaces(unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
 	return &meta.VersionInterfaces{
-		ObjectConvertor:  &unstructured.UnstructuredObjectConverter{},
+		ObjectConvertor:  &runtime.UnstructuredObjectConverter{},
 		MetadataAccessor: meta.NewAccessor(),
 	}, nil
 }

 // NewDiscoveryRESTMapper returns a RESTMapper based on discovery information.
-func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
+func NewDiscoveryRESTMapper(resources []*unversioned.APIResourceList, versionFunc meta.VersionInterfacesFunc) (*meta.DefaultRESTMapper, error) {
 	rm := meta.NewDefaultRESTMapper(nil, versionFunc)
 	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -57,16 +55,16 @@ func NewDiscoveryRESTMapper(resources []*metav1.APIResourceList, versionFunc met
 }

 // ObjectTyper provides an ObjectTyper implementation for
-// unstructured.Unstructured object based on discovery information.
+// runtime.Unstructured object based on discovery information.
 type ObjectTyper struct {
-	registered map[schema.GroupVersionKind]bool
+	registered map[unversioned.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)}
+func NewObjectTyper(resources []*unversioned.APIResourceList) (runtime.ObjectTyper, error) {
+	ot := &ObjectTyper{registered: make(map[unversioned.GroupVersionKind]bool)}
 	for _, resourceList := range resources {
-		gv, err := schema.ParseGroupVersion(resourceList.GroupVersion)
+		gv, err := unversioned.ParseGroupVersion(resourceList.GroupVersion)
 		if err != nil {
 			return nil, err
 		}
@@ -80,17 +78,17 @@ func NewObjectTyper(resources []*metav1.APIResourceList) (runtime.ObjectTyper, e

 // 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
+// object is not *runtime.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 {
+func (ot *ObjectTyper) ObjectKinds(obj runtime.Object) ([]unversioned.GroupVersionKind, bool, error) {
+	if _, ok := obj.(*runtime.Unstructured); !ok {
 		return nil, false, fmt.Errorf("type %T is invalid for dynamic object typer", obj)
 	}
-	return []schema.GroupVersionKind{obj.GetObjectKind().GroupVersionKind()}, false, nil
+	return []unversioned.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 {
+func (ot *ObjectTyper) Recognizes(gvk unversioned.GroupVersionKind) bool {
 	return ot.registered[gvk]
 }
--- a/dynamic/dynamic_util_test.go
+++ b/dynamic/dynamic_util_test.go
@@ -19,15 +19,14 @@ package dynamic
 import (
 	"testing"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/pkg/api/unversioned"
 )

 func TestDiscoveryRESTMapper(t *testing.T) {
-	resources := []*metav1.APIResourceList{
+	resources := []*unversioned.APIResourceList{
 		{
 			GroupVersion: "test/beta1",
-			APIResources: []metav1.APIResource{
+			APIResources: []unversioned.APIResource{
 				{
 					Name:       "test_kinds",
 					Namespaced: true,
@@ -37,7 +36,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		},
 	}

-	gvk := schema.GroupVersionKind{
+	gvk := unversioned.GroupVersionKind{
 		Group:   "test",
 		Version: "beta1",
 		Kind:    "test_kind",
@@ -48,7 +47,7 @@ func TestDiscoveryRESTMapper(t *testing.T) {
 		t.Fatalf("unexpected error creating mapper: %s", err)
 	}

-	for _, res := range []schema.GroupVersionResource{
+	for _, res := range []unversioned.GroupVersionResource{
 		{
 			Group:    "test",
 			Version:  "beta1",
--- a/examples/in-cluster/main.go
+++ b/examples/in-cluster/main.go
@@ -14,15 +14,14 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-// Note: the example only works with the code within the same release/branch.
 package main

 import (
 	"fmt"
 	"time"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/rest"
 )

@@ -38,7 +37,7 @@ func main() {
 		panic(err.Error())
 	}
 	for {
-		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
+		pods, err := clientset.Core().Pods("").List(v1.ListOptions{})
 		if err != nil {
 			panic(err.Error())
 		}
--- a/examples/out-of-cluster/main.go
+++ b/examples/out-of-cluster/main.go
@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-// Note: the example only works with the code within the same release/branch.
 package main

 import (
@@ -22,13 +21,16 @@ import (
 	"fmt"
 	"time"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/tools/clientcmd"
 )

+var (
+	kubeconfig = flag.String("kubeconfig", "./config", "absolute path to the kubeconfig file")
+)
+
 func main() {
-	kubeconfig := flag.String("kubeconfig", "./config", "absolute path to the kubeconfig file")
 	flag.Parse()
 	// uses the current context in kubeconfig
 	config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
@@ -41,7 +43,7 @@ func main() {
 		panic(err.Error())
 	}
 	for {
-		pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{})
+		pods, err := clientset.Core().Pods("").List(v1.ListOptions{})
 		if err != nil {
 			panic(err.Error())
 		}
--- a/examples/third-party-resources/main.go
+++ b/examples/third-party-resources/main.go
@@ -14,21 +14,20 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-// Note: the example only works with the code within the same release/branch.
 package main

 import (
 	"flag"
 	"fmt"

-	"k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/errors"
+	"k8s.io/client-go/pkg/api/unversioned"
+	"k8s.io/client-go/pkg/api/v1"
 	"k8s.io/client-go/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/runtime/serializer"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"

@@ -36,6 +35,10 @@ import (
 	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
 )

+var (
+	config *rest.Config
+)
+
 func main() {
 	kubeconfig := flag.String("kubeconfig", "", "Path to a kube config. Only required if out-of-cluster.")
 	flag.Parse()
@@ -52,11 +55,11 @@ func main() {
 	}

 	// initialize third party resource if it does not exist
-	tpr, err := clientset.ExtensionsV1beta1().ThirdPartyResources().Get("example.k8s.io", metav1.GetOptions{})
+	tpr, err := clientset.Extensions().ThirdPartyResources().Get("example.k8s.io")
 	if err != nil {
 		if errors.IsNotFound(err) {
 			tpr := &v1beta1.ThirdPartyResource{
-				ObjectMeta: metav1.ObjectMeta{
+				ObjectMeta: v1.ObjectMeta{
 					Name: "example.k8s.io",
 				},
 				Versions: []v1beta1.APIVersion{
@@ -65,7 +68,7 @@ func main() {
 				Description: "An Example ThirdPartyResource",
 			}

-			result, err := clientset.ExtensionsV1beta1().ThirdPartyResources().Create(tpr)
+			result, err := clientset.Extensions().ThirdPartyResources().Create(tpr)
 			if err != nil {
 				panic(err)
 			}
@@ -99,7 +102,7 @@ func main() {
 		if errors.IsNotFound(err) {
 			// Create an instance of our TPR
 			example := &Example{
-				Metadata: metav1.ObjectMeta{
+				Metadata: api.ObjectMeta{
 					Name: "example1",
 				},
 				Spec: ExampleSpec{
@@ -143,7 +146,7 @@ func buildConfig(kubeconfig string) (*rest.Config, error) {
 }

 func configureClient(config *rest.Config) {
-	groupversion := schema.GroupVersion{
+	groupversion := unversioned.GroupVersion{
 		Group:   "k8s.io",
 		Version: "v1",
 	}
@@ -159,9 +162,10 @@ func configureClient(config *rest.Config) {
 				groupversion,
 				&Example{},
 				&ExampleList{},
+				&api.ListOptions{},
+				&api.DeleteOptions{},
 			)
 			return nil
 		})
-	metav1.AddToGroupVersion(api.Scheme, groupversion)
 	schemeBuilder.AddToScheme(api.Scheme)
 }
--- a/examples/third-party-resources/types.go
+++ b/examples/third-party-resources/types.go
@@ -19,8 +19,9 @@ package main
 import (
 	"encoding/json"

-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/api/meta"
+	"k8s.io/client-go/pkg/api/unversioned"
 )

 type ExampleSpec struct {
@@ -29,36 +30,36 @@ type ExampleSpec struct {
 }

 type Example struct {
-	metav1.TypeMeta `json:",inline"`
-	Metadata        metav1.ObjectMeta `json:"metadata"`
+	unversioned.TypeMeta `json:",inline"`
+	Metadata             api.ObjectMeta `json:"metadata"`

 	Spec ExampleSpec `json:"spec"`
 }

 type ExampleList struct {
-	metav1.TypeMeta `json:",inline"`
-	Metadata        metav1.ListMeta `json:"metadata"`
+	unversioned.TypeMeta `json:",inline"`
+	Metadata             unversioned.ListMeta `json:"metadata"`

 	Items []Example `json:"items"`
 }

 // Required to satisfy Object interface
-func (e *Example) GetObjectKind() schema.ObjectKind {
+func (e *Example) GetObjectKind() unversioned.ObjectKind {
 	return &e.TypeMeta
 }

 // Required to satisfy ObjectMetaAccessor interface
-func (e *Example) GetObjectMeta() metav1.Object {
+func (e *Example) GetObjectMeta() meta.Object {
 	return &e.Metadata
 }

 // Required to satisfy Object interface
-func (el *ExampleList) GetObjectKind() schema.ObjectKind {
+func (el *ExampleList) GetObjectKind() unversioned.ObjectKind {
 	return &el.TypeMeta
 }

 // Required to satisfy ListMetaAccessor interface
-func (el *ExampleList) GetListMeta() metav1.List {
+func (el *ExampleList) GetListMeta() unversioned.List {
 	return &el.Metadata
 }

--- a/examples/third-party-resources/types_test.go
+++ b/examples/third-party-resources/types_test.go
@@ -1,28 +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 main
-
-import (
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-var _ runtime.Object = &Example{}
-var _ metav1.ObjectMetaAccessor = &Example{}
-
-var _ runtime.Object = &ExampleList{}
-var _ metav1.ListMetaAccessor = &ExampleList{}
--- a/informers/apps/interface.go
+++ b/informers/apps/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package apps
-
-import (
-	v1beta1 "k8s.io/client-go/informers/apps/v1beta1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/apps/v1beta1/deployment.go
+++ b/informers/apps/v1beta1/deployment.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/apps/v1beta1"
-	apps_v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// DeploymentInformer provides access to a shared informer and lister for
-// Deployments.
-type DeploymentInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.DeploymentLister
-}
-
-type deploymentInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newDeploymentInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.AppsV1beta1().Deployments(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.AppsV1beta1().Deployments(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&apps_v1beta1.Deployment{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&apps_v1beta1.Deployment{}, newDeploymentInformer)
-}
-
-func (f *deploymentInformer) Lister() v1beta1.DeploymentLister {
-	return v1beta1.NewDeploymentLister(f.Informer().GetIndexer())
-}
--- a/informers/apps/v1beta1/interface.go
+++ b/informers/apps/v1beta1/interface.go
@@ -1,50 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// Deployments returns a DeploymentInformer.
-	Deployments() DeploymentInformer
-	// StatefulSets returns a StatefulSetInformer.
-	StatefulSets() StatefulSetInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// Deployments returns a DeploymentInformer.
-func (v *version) Deployments() DeploymentInformer {
-	return &deploymentInformer{factory: v.SharedInformerFactory}
-}
-
-// StatefulSets returns a StatefulSetInformer.
-func (v *version) StatefulSets() StatefulSetInformer {
-	return &statefulSetInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/apps/v1beta1/statefulset.go
+++ b/informers/apps/v1beta1/statefulset.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/apps/v1beta1"
-	apps_v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// StatefulSetInformer provides access to a shared informer and lister for
-// StatefulSets.
-type StatefulSetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.StatefulSetLister
-}
-
-type statefulSetInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newStatefulSetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.AppsV1beta1().StatefulSets(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.AppsV1beta1().StatefulSets(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&apps_v1beta1.StatefulSet{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *statefulSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&apps_v1beta1.StatefulSet{}, newStatefulSetInformer)
-}
-
-func (f *statefulSetInformer) Lister() v1beta1.StatefulSetLister {
-	return v1beta1.NewStatefulSetLister(f.Informer().GetIndexer())
-}
--- a/informers/autoscaling/interface.go
+++ b/informers/autoscaling/interface.go
@@ -1,52 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package autoscaling
-
-import (
-	v1 "k8s.io/client-go/informers/autoscaling/v1"
-	v2alpha1 "k8s.io/client-go/informers/autoscaling/v2alpha1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1 provides access to shared informers for resources in V1.
-	V1() v1.Interface
-	// V2alpha1 provides access to shared informers for resources in V2alpha1.
-	V2alpha1() v2alpha1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1 returns a new v1.Interface.
-func (g *group) V1() v1.Interface {
-	return v1.New(g.SharedInformerFactory)
-}
-
-// V2alpha1 returns a new v2alpha1.Interface.
-func (g *group) V2alpha1() v2alpha1.Interface {
-	return v2alpha1.New(g.SharedInformerFactory)
-}
--- a/informers/autoscaling/v1/horizontalpodautoscaler.go
+++ b/informers/autoscaling/v1/horizontalpodautoscaler.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/autoscaling/v1"
-	autoscaling_v1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for
-// HorizontalPodAutoscalers.
-type HorizontalPodAutoscalerInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.HorizontalPodAutoscalerLister
-}
-
-type horizontalPodAutoscalerInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newHorizontalPodAutoscalerInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.AutoscalingV1().HorizontalPodAutoscalers(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.AutoscalingV1().HorizontalPodAutoscalers(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&autoscaling_v1.HorizontalPodAutoscaler{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&autoscaling_v1.HorizontalPodAutoscaler{}, newHorizontalPodAutoscalerInformer)
-}
-
-func (f *horizontalPodAutoscalerInformer) Lister() v1.HorizontalPodAutoscalerLister {
-	return v1.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer())
-}
--- a/informers/autoscaling/v1/interface.go
+++ b/informers/autoscaling/v1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
-	return &horizontalPodAutoscalerInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/autoscaling/v2alpha1/horizontalpodautoscaler.go
+++ b/informers/autoscaling/v2alpha1/horizontalpodautoscaler.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v2alpha1
-
-import (
-	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"
-	v2alpha1 "k8s.io/client-go/listers/autoscaling/v2alpha1"
-	autoscaling_v2alpha1 "k8s.io/client-go/pkg/apis/autoscaling/v2alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// HorizontalPodAutoscalerInformer provides access to a shared informer and lister for
-// HorizontalPodAutoscalers.
-type HorizontalPodAutoscalerInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v2alpha1.HorizontalPodAutoscalerLister
-}
-
-type horizontalPodAutoscalerInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newHorizontalPodAutoscalerInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.AutoscalingV2alpha1().HorizontalPodAutoscalers(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.AutoscalingV2alpha1().HorizontalPodAutoscalers(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&autoscaling_v2alpha1.HorizontalPodAutoscaler{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *horizontalPodAutoscalerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&autoscaling_v2alpha1.HorizontalPodAutoscaler{}, newHorizontalPodAutoscalerInformer)
-}
-
-func (f *horizontalPodAutoscalerInformer) Lister() v2alpha1.HorizontalPodAutoscalerLister {
-	return v2alpha1.NewHorizontalPodAutoscalerLister(f.Informer().GetIndexer())
-}
--- a/informers/autoscaling/v2alpha1/interface.go
+++ b/informers/autoscaling/v2alpha1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v2alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-	HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// HorizontalPodAutoscalers returns a HorizontalPodAutoscalerInformer.
-func (v *version) HorizontalPodAutoscalers() HorizontalPodAutoscalerInformer {
-	return &horizontalPodAutoscalerInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/batch/interface.go
+++ b/informers/batch/interface.go
@@ -1,52 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package batch
-
-import (
-	v1 "k8s.io/client-go/informers/batch/v1"
-	v2alpha1 "k8s.io/client-go/informers/batch/v2alpha1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1 provides access to shared informers for resources in V1.
-	V1() v1.Interface
-	// V2alpha1 provides access to shared informers for resources in V2alpha1.
-	V2alpha1() v2alpha1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1 returns a new v1.Interface.
-func (g *group) V1() v1.Interface {
-	return v1.New(g.SharedInformerFactory)
-}
-
-// V2alpha1 returns a new v2alpha1.Interface.
-func (g *group) V2alpha1() v2alpha1.Interface {
-	return v2alpha1.New(g.SharedInformerFactory)
-}
--- a/informers/batch/v1/interface.go
+++ b/informers/batch/v1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// Jobs returns a JobInformer.
-	Jobs() JobInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// Jobs returns a JobInformer.
-func (v *version) Jobs() JobInformer {
-	return &jobInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/batch/v1/job.go
+++ b/informers/batch/v1/job.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/batch/v1"
-	batch_v1 "k8s.io/client-go/pkg/apis/batch/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// JobInformer provides access to a shared informer and lister for
-// Jobs.
-type JobInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.JobLister
-}
-
-type jobInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newJobInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.BatchV1().Jobs(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.BatchV1().Jobs(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&batch_v1.Job{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *jobInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&batch_v1.Job{}, newJobInformer)
-}
-
-func (f *jobInformer) Lister() v1.JobLister {
-	return v1.NewJobLister(f.Informer().GetIndexer())
-}
--- a/informers/batch/v2alpha1/cronjob.go
+++ b/informers/batch/v2alpha1/cronjob.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v2alpha1
-
-import (
-	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"
-	v2alpha1 "k8s.io/client-go/listers/batch/v2alpha1"
-	batch_v2alpha1 "k8s.io/client-go/pkg/apis/batch/v2alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// CronJobInformer provides access to a shared informer and lister for
-// CronJobs.
-type CronJobInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v2alpha1.CronJobLister
-}
-
-type cronJobInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newCronJobInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.BatchV2alpha1().CronJobs(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.BatchV2alpha1().CronJobs(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&batch_v2alpha1.CronJob{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *cronJobInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&batch_v2alpha1.CronJob{}, newCronJobInformer)
-}
-
-func (f *cronJobInformer) Lister() v2alpha1.CronJobLister {
-	return v2alpha1.NewCronJobLister(f.Informer().GetIndexer())
-}
--- a/informers/batch/v2alpha1/interface.go
+++ b/informers/batch/v2alpha1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v2alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// CronJobs returns a CronJobInformer.
-	CronJobs() CronJobInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// CronJobs returns a CronJobInformer.
-func (v *version) CronJobs() CronJobInformer {
-	return &cronJobInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/certificates/interface.go
+++ b/informers/certificates/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package certificates
-
-import (
-	v1beta1 "k8s.io/client-go/informers/certificates/v1beta1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/certificates/v1beta1/certificatesigningrequest.go
+++ b/informers/certificates/v1beta1/certificatesigningrequest.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/certificates/v1beta1"
-	certificates_v1beta1 "k8s.io/client-go/pkg/apis/certificates/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// CertificateSigningRequestInformer provides access to a shared informer and lister for
-// CertificateSigningRequests.
-type CertificateSigningRequestInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.CertificateSigningRequestLister
-}
-
-type certificateSigningRequestInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newCertificateSigningRequestInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.CertificatesV1beta1().CertificateSigningRequests().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.CertificatesV1beta1().CertificateSigningRequests().Watch(options)
-			},
-		},
-		&certificates_v1beta1.CertificateSigningRequest{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *certificateSigningRequestInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&certificates_v1beta1.CertificateSigningRequest{}, newCertificateSigningRequestInformer)
-}
-
-func (f *certificateSigningRequestInformer) Lister() v1beta1.CertificateSigningRequestLister {
-	return v1beta1.NewCertificateSigningRequestLister(f.Informer().GetIndexer())
-}
--- a/informers/certificates/v1beta1/interface.go
+++ b/informers/certificates/v1beta1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// CertificateSigningRequests returns a CertificateSigningRequestInformer.
-	CertificateSigningRequests() CertificateSigningRequestInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// CertificateSigningRequests returns a CertificateSigningRequestInformer.
-func (v *version) CertificateSigningRequests() CertificateSigningRequestInformer {
-	return &certificateSigningRequestInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/core/interface.go
+++ b/informers/core/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package core
-
-import (
-	v1 "k8s.io/client-go/informers/core/v1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1 provides access to shared informers for resources in V1.
-	V1() v1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1 returns a new v1.Interface.
-func (g *group) V1() v1.Interface {
-	return v1.New(g.SharedInformerFactory)
-}
--- a/informers/core/v1/componentstatus.go
+++ b/informers/core/v1/componentstatus.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ComponentStatusInformer provides access to a shared informer and lister for
-// ComponentStatuses.
-type ComponentStatusInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ComponentStatusLister
-}
-
-type componentStatusInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newComponentStatusInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().ComponentStatuses().List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().ComponentStatuses().Watch(options)
-			},
-		},
-		&api_v1.ComponentStatus{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *componentStatusInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.ComponentStatus{}, newComponentStatusInformer)
-}
-
-func (f *componentStatusInformer) Lister() v1.ComponentStatusLister {
-	return v1.NewComponentStatusLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/configmap.go
+++ b/informers/core/v1/configmap.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ConfigMapInformer provides access to a shared informer and lister for
-// ConfigMaps.
-type ConfigMapInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ConfigMapLister
-}
-
-type configMapInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newConfigMapInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().ConfigMaps(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().ConfigMaps(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.ConfigMap{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *configMapInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.ConfigMap{}, newConfigMapInformer)
-}
-
-func (f *configMapInformer) Lister() v1.ConfigMapLister {
-	return v1.NewConfigMapLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/endpoints.go
+++ b/informers/core/v1/endpoints.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// EndpointsInformer provides access to a shared informer and lister for
-// Endpoints.
-type EndpointsInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.EndpointsLister
-}
-
-type endpointsInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newEndpointsInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Endpoints(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Endpoints(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.Endpoints{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *endpointsInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Endpoints{}, newEndpointsInformer)
-}
-
-func (f *endpointsInformer) Lister() v1.EndpointsLister {
-	return v1.NewEndpointsLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/event.go
+++ b/informers/core/v1/event.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// EventInformer provides access to a shared informer and lister for
-// Events.
-type EventInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.EventLister
-}
-
-type eventInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newEventInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Events(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Events(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.Event{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *eventInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Event{}, newEventInformer)
-}
-
-func (f *eventInformer) Lister() v1.EventLister {
-	return v1.NewEventLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/interface.go
+++ b/informers/core/v1/interface.go
@@ -1,148 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// ComponentStatuses returns a ComponentStatusInformer.
-	ComponentStatuses() ComponentStatusInformer
-	// ConfigMaps returns a ConfigMapInformer.
-	ConfigMaps() ConfigMapInformer
-	// Endpoints returns a EndpointsInformer.
-	Endpoints() EndpointsInformer
-	// Events returns a EventInformer.
-	Events() EventInformer
-	// LimitRanges returns a LimitRangeInformer.
-	LimitRanges() LimitRangeInformer
-	// Namespaces returns a NamespaceInformer.
-	Namespaces() NamespaceInformer
-	// Nodes returns a NodeInformer.
-	Nodes() NodeInformer
-	// PersistentVolumes returns a PersistentVolumeInformer.
-	PersistentVolumes() PersistentVolumeInformer
-	// PersistentVolumeClaims returns a PersistentVolumeClaimInformer.
-	PersistentVolumeClaims() PersistentVolumeClaimInformer
-	// Pods returns a PodInformer.
-	Pods() PodInformer
-	// PodTemplates returns a PodTemplateInformer.
-	PodTemplates() PodTemplateInformer
-	// ReplicationControllers returns a ReplicationControllerInformer.
-	ReplicationControllers() ReplicationControllerInformer
-	// ResourceQuotas returns a ResourceQuotaInformer.
-	ResourceQuotas() ResourceQuotaInformer
-	// Secrets returns a SecretInformer.
-	Secrets() SecretInformer
-	// Services returns a ServiceInformer.
-	Services() ServiceInformer
-	// ServiceAccounts returns a ServiceAccountInformer.
-	ServiceAccounts() ServiceAccountInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// ComponentStatuses returns a ComponentStatusInformer.
-func (v *version) ComponentStatuses() ComponentStatusInformer {
-	return &componentStatusInformer{factory: v.SharedInformerFactory}
-}
-
-// ConfigMaps returns a ConfigMapInformer.
-func (v *version) ConfigMaps() ConfigMapInformer {
-	return &configMapInformer{factory: v.SharedInformerFactory}
-}
-
-// Endpoints returns a EndpointsInformer.
-func (v *version) Endpoints() EndpointsInformer {
-	return &endpointsInformer{factory: v.SharedInformerFactory}
-}
-
-// Events returns a EventInformer.
-func (v *version) Events() EventInformer {
-	return &eventInformer{factory: v.SharedInformerFactory}
-}
-
-// LimitRanges returns a LimitRangeInformer.
-func (v *version) LimitRanges() LimitRangeInformer {
-	return &limitRangeInformer{factory: v.SharedInformerFactory}
-}
-
-// Namespaces returns a NamespaceInformer.
-func (v *version) Namespaces() NamespaceInformer {
-	return &namespaceInformer{factory: v.SharedInformerFactory}
-}
-
-// Nodes returns a NodeInformer.
-func (v *version) Nodes() NodeInformer {
-	return &nodeInformer{factory: v.SharedInformerFactory}
-}
-
-// PersistentVolumes returns a PersistentVolumeInformer.
-func (v *version) PersistentVolumes() PersistentVolumeInformer {
-	return &persistentVolumeInformer{factory: v.SharedInformerFactory}
-}
-
-// PersistentVolumeClaims returns a PersistentVolumeClaimInformer.
-func (v *version) PersistentVolumeClaims() PersistentVolumeClaimInformer {
-	return &persistentVolumeClaimInformer{factory: v.SharedInformerFactory}
-}
-
-// Pods returns a PodInformer.
-func (v *version) Pods() PodInformer {
-	return &podInformer{factory: v.SharedInformerFactory}
-}
-
-// PodTemplates returns a PodTemplateInformer.
-func (v *version) PodTemplates() PodTemplateInformer {
-	return &podTemplateInformer{factory: v.SharedInformerFactory}
-}
-
-// ReplicationControllers returns a ReplicationControllerInformer.
-func (v *version) ReplicationControllers() ReplicationControllerInformer {
-	return &replicationControllerInformer{factory: v.SharedInformerFactory}
-}
-
-// ResourceQuotas returns a ResourceQuotaInformer.
-func (v *version) ResourceQuotas() ResourceQuotaInformer {
-	return &resourceQuotaInformer{factory: v.SharedInformerFactory}
-}
-
-// Secrets returns a SecretInformer.
-func (v *version) Secrets() SecretInformer {
-	return &secretInformer{factory: v.SharedInformerFactory}
-}
-
-// Services returns a ServiceInformer.
-func (v *version) Services() ServiceInformer {
-	return &serviceInformer{factory: v.SharedInformerFactory}
-}
-
-// ServiceAccounts returns a ServiceAccountInformer.
-func (v *version) ServiceAccounts() ServiceAccountInformer {
-	return &serviceAccountInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/core/v1/limitrange.go
+++ b/informers/core/v1/limitrange.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// LimitRangeInformer provides access to a shared informer and lister for
-// LimitRanges.
-type LimitRangeInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.LimitRangeLister
-}
-
-type limitRangeInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newLimitRangeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().LimitRanges(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().LimitRanges(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.LimitRange{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *limitRangeInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.LimitRange{}, newLimitRangeInformer)
-}
-
-func (f *limitRangeInformer) Lister() v1.LimitRangeLister {
-	return v1.NewLimitRangeLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/namespace.go
+++ b/informers/core/v1/namespace.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// NamespaceInformer provides access to a shared informer and lister for
-// Namespaces.
-type NamespaceInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.NamespaceLister
-}
-
-type namespaceInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newNamespaceInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Namespaces().List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Namespaces().Watch(options)
-			},
-		},
-		&api_v1.Namespace{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *namespaceInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Namespace{}, newNamespaceInformer)
-}
-
-func (f *namespaceInformer) Lister() v1.NamespaceLister {
-	return v1.NewNamespaceLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/node.go
+++ b/informers/core/v1/node.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// NodeInformer provides access to a shared informer and lister for
-// Nodes.
-type NodeInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.NodeLister
-}
-
-type nodeInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newNodeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Nodes().List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Nodes().Watch(options)
-			},
-		},
-		&api_v1.Node{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *nodeInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Node{}, newNodeInformer)
-}
-
-func (f *nodeInformer) Lister() v1.NodeLister {
-	return v1.NewNodeLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/persistentvolume.go
+++ b/informers/core/v1/persistentvolume.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PersistentVolumeInformer provides access to a shared informer and lister for
-// PersistentVolumes.
-type PersistentVolumeInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.PersistentVolumeLister
-}
-
-type persistentVolumeInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPersistentVolumeInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().PersistentVolumes().List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().PersistentVolumes().Watch(options)
-			},
-		},
-		&api_v1.PersistentVolume{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *persistentVolumeInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.PersistentVolume{}, newPersistentVolumeInformer)
-}
-
-func (f *persistentVolumeInformer) Lister() v1.PersistentVolumeLister {
-	return v1.NewPersistentVolumeLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/persistentvolumeclaim.go
+++ b/informers/core/v1/persistentvolumeclaim.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PersistentVolumeClaimInformer provides access to a shared informer and lister for
-// PersistentVolumeClaims.
-type PersistentVolumeClaimInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.PersistentVolumeClaimLister
-}
-
-type persistentVolumeClaimInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPersistentVolumeClaimInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().PersistentVolumeClaims(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().PersistentVolumeClaims(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.PersistentVolumeClaim{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *persistentVolumeClaimInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.PersistentVolumeClaim{}, newPersistentVolumeClaimInformer)
-}
-
-func (f *persistentVolumeClaimInformer) Lister() v1.PersistentVolumeClaimLister {
-	return v1.NewPersistentVolumeClaimLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/pod.go
+++ b/informers/core/v1/pod.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PodInformer provides access to a shared informer and lister for
-// Pods.
-type PodInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.PodLister
-}
-
-type podInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPodInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Pods(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Pods(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.Pod{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *podInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Pod{}, newPodInformer)
-}
-
-func (f *podInformer) Lister() v1.PodLister {
-	return v1.NewPodLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/podtemplate.go
+++ b/informers/core/v1/podtemplate.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PodTemplateInformer provides access to a shared informer and lister for
-// PodTemplates.
-type PodTemplateInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.PodTemplateLister
-}
-
-type podTemplateInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPodTemplateInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().PodTemplates(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().PodTemplates(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.PodTemplate{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *podTemplateInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.PodTemplate{}, newPodTemplateInformer)
-}
-
-func (f *podTemplateInformer) Lister() v1.PodTemplateLister {
-	return v1.NewPodTemplateLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/replicationcontroller.go
+++ b/informers/core/v1/replicationcontroller.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ReplicationControllerInformer provides access to a shared informer and lister for
-// ReplicationControllers.
-type ReplicationControllerInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ReplicationControllerLister
-}
-
-type replicationControllerInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newReplicationControllerInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().ReplicationControllers(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().ReplicationControllers(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.ReplicationController{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *replicationControllerInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.ReplicationController{}, newReplicationControllerInformer)
-}
-
-func (f *replicationControllerInformer) Lister() v1.ReplicationControllerLister {
-	return v1.NewReplicationControllerLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/resourcequota.go
+++ b/informers/core/v1/resourcequota.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ResourceQuotaInformer provides access to a shared informer and lister for
-// ResourceQuotas.
-type ResourceQuotaInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ResourceQuotaLister
-}
-
-type resourceQuotaInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newResourceQuotaInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().ResourceQuotas(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().ResourceQuotas(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.ResourceQuota{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *resourceQuotaInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.ResourceQuota{}, newResourceQuotaInformer)
-}
-
-func (f *resourceQuotaInformer) Lister() v1.ResourceQuotaLister {
-	return v1.NewResourceQuotaLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/secret.go
+++ b/informers/core/v1/secret.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// SecretInformer provides access to a shared informer and lister for
-// Secrets.
-type SecretInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.SecretLister
-}
-
-type secretInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newSecretInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Secrets(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Secrets(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.Secret{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *secretInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Secret{}, newSecretInformer)
-}
-
-func (f *secretInformer) Lister() v1.SecretLister {
-	return v1.NewSecretLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/service.go
+++ b/informers/core/v1/service.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ServiceInformer provides access to a shared informer and lister for
-// Services.
-type ServiceInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ServiceLister
-}
-
-type serviceInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newServiceInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().Services(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().Services(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.Service{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *serviceInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.Service{}, newServiceInformer)
-}
-
-func (f *serviceInformer) Lister() v1.ServiceLister {
-	return v1.NewServiceLister(f.Informer().GetIndexer())
-}
--- a/informers/core/v1/serviceaccount.go
+++ b/informers/core/v1/serviceaccount.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/core/v1"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ServiceAccountInformer provides access to a shared informer and lister for
-// ServiceAccounts.
-type ServiceAccountInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.ServiceAccountLister
-}
-
-type serviceAccountInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newServiceAccountInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.CoreV1().ServiceAccounts(meta_v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.CoreV1().ServiceAccounts(meta_v1.NamespaceAll).Watch(options)
-			},
-		},
-		&api_v1.ServiceAccount{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *serviceAccountInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&api_v1.ServiceAccount{}, newServiceAccountInformer)
-}
-
-func (f *serviceAccountInformer) Lister() v1.ServiceAccountLister {
-	return v1.NewServiceAccountLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/interface.go
+++ b/informers/extensions/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package extensions
-
-import (
-	v1beta1 "k8s.io/client-go/informers/extensions/v1beta1"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/extensions/v1beta1/daemonset.go
+++ b/informers/extensions/v1beta1/daemonset.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// DaemonSetInformer provides access to a shared informer and lister for
-// DaemonSets.
-type DaemonSetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.DaemonSetLister
-}
-
-type daemonSetInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newDaemonSetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().DaemonSets(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().DaemonSets(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions_v1beta1.DaemonSet{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *daemonSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.DaemonSet{}, newDaemonSetInformer)
-}
-
-func (f *daemonSetInformer) Lister() v1beta1.DaemonSetLister {
-	return v1beta1.NewDaemonSetLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/v1beta1/deployment.go
+++ b/informers/extensions/v1beta1/deployment.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// DeploymentInformer provides access to a shared informer and lister for
-// Deployments.
-type DeploymentInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.DeploymentLister
-}
-
-type deploymentInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newDeploymentInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().Deployments(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().Deployments(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions_v1beta1.Deployment{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *deploymentInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.Deployment{}, newDeploymentInformer)
-}
-
-func (f *deploymentInformer) Lister() v1beta1.DeploymentLister {
-	return v1beta1.NewDeploymentLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/v1beta1/ingress.go
+++ b/informers/extensions/v1beta1/ingress.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// IngressInformer provides access to a shared informer and lister for
-// Ingresses.
-type IngressInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.IngressLister
-}
-
-type ingressInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newIngressInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().Ingresses(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().Ingresses(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions_v1beta1.Ingress{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *ingressInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.Ingress{}, newIngressInformer)
-}
-
-func (f *ingressInformer) Lister() v1beta1.IngressLister {
-	return v1beta1.NewIngressLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/v1beta1/interface.go
+++ b/informers/extensions/v1beta1/interface.go
@@ -1,78 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// DaemonSets returns a DaemonSetInformer.
-	DaemonSets() DaemonSetInformer
-	// Deployments returns a DeploymentInformer.
-	Deployments() DeploymentInformer
-	// Ingresses returns a IngressInformer.
-	Ingresses() IngressInformer
-	// PodSecurityPolicies returns a PodSecurityPolicyInformer.
-	PodSecurityPolicies() PodSecurityPolicyInformer
-	// ReplicaSets returns a ReplicaSetInformer.
-	ReplicaSets() ReplicaSetInformer
-	// ThirdPartyResources returns a ThirdPartyResourceInformer.
-	ThirdPartyResources() ThirdPartyResourceInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// DaemonSets returns a DaemonSetInformer.
-func (v *version) DaemonSets() DaemonSetInformer {
-	return &daemonSetInformer{factory: v.SharedInformerFactory}
-}
-
-// Deployments returns a DeploymentInformer.
-func (v *version) Deployments() DeploymentInformer {
-	return &deploymentInformer{factory: v.SharedInformerFactory}
-}
-
-// Ingresses returns a IngressInformer.
-func (v *version) Ingresses() IngressInformer {
-	return &ingressInformer{factory: v.SharedInformerFactory}
-}
-
-// PodSecurityPolicies returns a PodSecurityPolicyInformer.
-func (v *version) PodSecurityPolicies() PodSecurityPolicyInformer {
-	return &podSecurityPolicyInformer{factory: v.SharedInformerFactory}
-}
-
-// ReplicaSets returns a ReplicaSetInformer.
-func (v *version) ReplicaSets() ReplicaSetInformer {
-	return &replicaSetInformer{factory: v.SharedInformerFactory}
-}
-
-// ThirdPartyResources returns a ThirdPartyResourceInformer.
-func (v *version) ThirdPartyResources() ThirdPartyResourceInformer {
-	return &thirdPartyResourceInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/extensions/v1beta1/podsecuritypolicy.go
+++ b/informers/extensions/v1beta1/podsecuritypolicy.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PodSecurityPolicyInformer provides access to a shared informer and lister for
-// PodSecurityPolicies.
-type PodSecurityPolicyInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.PodSecurityPolicyLister
-}
-
-type podSecurityPolicyInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPodSecurityPolicyInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().PodSecurityPolicies().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().PodSecurityPolicies().Watch(options)
-			},
-		},
-		&extensions_v1beta1.PodSecurityPolicy{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *podSecurityPolicyInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.PodSecurityPolicy{}, newPodSecurityPolicyInformer)
-}
-
-func (f *podSecurityPolicyInformer) Lister() v1beta1.PodSecurityPolicyLister {
-	return v1beta1.NewPodSecurityPolicyLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/v1beta1/replicaset.go
+++ b/informers/extensions/v1beta1/replicaset.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ReplicaSetInformer provides access to a shared informer and lister for
-// ReplicaSets.
-type ReplicaSetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.ReplicaSetLister
-}
-
-type replicaSetInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newReplicaSetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().ReplicaSets(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().ReplicaSets(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&extensions_v1beta1.ReplicaSet{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *replicaSetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.ReplicaSet{}, newReplicaSetInformer)
-}
-
-func (f *replicaSetInformer) Lister() v1beta1.ReplicaSetLister {
-	return v1beta1.NewReplicaSetLister(f.Informer().GetIndexer())
-}
--- a/informers/extensions/v1beta1/thirdpartyresource.go
+++ b/informers/extensions/v1beta1/thirdpartyresource.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/extensions/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ThirdPartyResourceInformer provides access to a shared informer and lister for
-// ThirdPartyResources.
-type ThirdPartyResourceInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.ThirdPartyResourceLister
-}
-
-type thirdPartyResourceInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newThirdPartyResourceInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.ExtensionsV1beta1().ThirdPartyResources().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.ExtensionsV1beta1().ThirdPartyResources().Watch(options)
-			},
-		},
-		&extensions_v1beta1.ThirdPartyResource{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *thirdPartyResourceInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&extensions_v1beta1.ThirdPartyResource{}, newThirdPartyResourceInformer)
-}
-
-func (f *thirdPartyResourceInformer) Lister() v1beta1.ThirdPartyResourceLister {
-	return v1beta1.NewThirdPartyResourceLister(f.Informer().GetIndexer())
-}
--- a/informers/factory.go
+++ b/informers/factory.go
@@ -1,149 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package informers
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	apps "k8s.io/client-go/informers/apps"
-	autoscaling "k8s.io/client-go/informers/autoscaling"
-	batch "k8s.io/client-go/informers/batch"
-	certificates "k8s.io/client-go/informers/certificates"
-	core "k8s.io/client-go/informers/core"
-	extensions "k8s.io/client-go/informers/extensions"
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	policy "k8s.io/client-go/informers/policy"
-	rbac "k8s.io/client-go/informers/rbac"
-	settings "k8s.io/client-go/informers/settings"
-	storage "k8s.io/client-go/informers/storage"
-	kubernetes "k8s.io/client-go/kubernetes"
-	cache "k8s.io/client-go/tools/cache"
-	reflect "reflect"
-	sync "sync"
-	time "time"
-)
-
-type sharedInformerFactory struct {
-	client        kubernetes.Interface
-	lock          sync.Mutex
-	defaultResync time.Duration
-
-	informers map[reflect.Type]cache.SharedIndexInformer
-	// startedInformers is used for tracking which informers have been started.
-	// This allows Start() to be called multiple times safely.
-	startedInformers map[reflect.Type]bool
-}
-
-// NewSharedInformerFactory constructs a new instance of sharedInformerFactory
-func NewSharedInformerFactory(client kubernetes.Interface, defaultResync time.Duration) SharedInformerFactory {
-	return &sharedInformerFactory{
-		client:           client,
-		defaultResync:    defaultResync,
-		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
-		startedInformers: make(map[reflect.Type]bool),
-	}
-}
-
-// Start initializes all requested informers.
-func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	for informerType, informer := range f.informers {
-		if !f.startedInformers[informerType] {
-			go informer.Run(stopCh)
-			f.startedInformers[informerType] = true
-		}
-	}
-}
-
-// InternalInformerFor returns the SharedIndexInformer for obj using an internal
-// client.
-func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
-	f.lock.Lock()
-	defer f.lock.Unlock()
-
-	informerType := reflect.TypeOf(obj)
-	informer, exists := f.informers[informerType]
-	if exists {
-		return informer
-	}
-	informer = newFunc(f.client, f.defaultResync)
-	f.informers[informerType] = informer
-
-	return informer
-}
-
-// SharedInformerFactory provides shared informers for resources in all known
-// API group versions.
-type SharedInformerFactory interface {
-	internalinterfaces.SharedInformerFactory
-	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
-
-	Apps() apps.Interface
-	Autoscaling() autoscaling.Interface
-	Batch() batch.Interface
-	Certificates() certificates.Interface
-	Core() core.Interface
-	Extensions() extensions.Interface
-	Policy() policy.Interface
-	Rbac() rbac.Interface
-	Settings() settings.Interface
-	Storage() storage.Interface
-}
-
-func (f *sharedInformerFactory) Apps() apps.Interface {
-	return apps.New(f)
-}
-
-func (f *sharedInformerFactory) Autoscaling() autoscaling.Interface {
-	return autoscaling.New(f)
-}
-
-func (f *sharedInformerFactory) Batch() batch.Interface {
-	return batch.New(f)
-}
-
-func (f *sharedInformerFactory) Certificates() certificates.Interface {
-	return certificates.New(f)
-}
-
-func (f *sharedInformerFactory) Core() core.Interface {
-	return core.New(f)
-}
-
-func (f *sharedInformerFactory) Extensions() extensions.Interface {
-	return extensions.New(f)
-}
-
-func (f *sharedInformerFactory) Policy() policy.Interface {
-	return policy.New(f)
-}
-
-func (f *sharedInformerFactory) Rbac() rbac.Interface {
-	return rbac.New(f)
-}
-
-func (f *sharedInformerFactory) Settings() settings.Interface {
-	return settings.New(f)
-}
-
-func (f *sharedInformerFactory) Storage() storage.Interface {
-	return storage.New(f)
-}
--- a/informers/generic.go
+++ b/informers/generic.go
@@ -1,180 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package informers
-
-import (
-	"fmt"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	api_v1 "k8s.io/client-go/pkg/api/v1"
-	v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
-	v1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
-	v2alpha1 "k8s.io/client-go/pkg/apis/autoscaling/v2alpha1"
-	batch_v1 "k8s.io/client-go/pkg/apis/batch/v1"
-	batch_v2alpha1 "k8s.io/client-go/pkg/apis/batch/v2alpha1"
-	certificates_v1beta1 "k8s.io/client-go/pkg/apis/certificates/v1beta1"
-	extensions_v1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	policy_v1beta1 "k8s.io/client-go/pkg/apis/policy/v1beta1"
-	v1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	rbac_v1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	settings_v1alpha1 "k8s.io/client-go/pkg/apis/settings/v1alpha1"
-	storage_v1 "k8s.io/client-go/pkg/apis/storage/v1"
-	storage_v1beta1 "k8s.io/client-go/pkg/apis/storage/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-)
-
-// GenericInformer is type of SharedIndexInformer which will locate and delegate to other
-// sharedInformers based on type
-type GenericInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() cache.GenericLister
-}
-
-type genericInformer struct {
-	informer cache.SharedIndexInformer
-	resource schema.GroupResource
-}
-
-// Informer returns the SharedIndexInformer.
-func (f *genericInformer) Informer() cache.SharedIndexInformer {
-	return f.informer
-}
-
-// Lister returns the GenericLister.
-func (f *genericInformer) Lister() cache.GenericLister {
-	return cache.NewGenericLister(f.Informer().GetIndexer(), f.resource)
-}
-
-// ForResource gives generic access to a shared informer of the matching type
-// TODO extend this to unknown resources with a client pool
-func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource) (GenericInformer, error) {
-	switch resource {
-	// Group=Apps, Version=V1beta1
-	case v1beta1.SchemeGroupVersion.WithResource("deployments"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Apps().V1beta1().Deployments().Informer()}, nil
-	case v1beta1.SchemeGroupVersion.WithResource("statefulsets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Apps().V1beta1().StatefulSets().Informer()}, nil
-
-		// Group=Autoscaling, Version=V1
-	case v1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V1().HorizontalPodAutoscalers().Informer()}, nil
-
-		// Group=Autoscaling, Version=V2alpha1
-	case v2alpha1.SchemeGroupVersion.WithResource("horizontalpodautoscalers"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Autoscaling().V2alpha1().HorizontalPodAutoscalers().Informer()}, nil
-
-		// Group=Batch, Version=V1
-	case batch_v1.SchemeGroupVersion.WithResource("jobs"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Batch().V1().Jobs().Informer()}, nil
-
-		// Group=Batch, Version=V2alpha1
-	case batch_v2alpha1.SchemeGroupVersion.WithResource("cronjobs"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Batch().V2alpha1().CronJobs().Informer()}, nil
-
-		// Group=Certificates, Version=V1beta1
-	case certificates_v1beta1.SchemeGroupVersion.WithResource("certificatesigningrequests"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Certificates().V1beta1().CertificateSigningRequests().Informer()}, nil
-
-		// Group=Core, Version=V1
-	case api_v1.SchemeGroupVersion.WithResource("componentstatuses"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().ComponentStatuses().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("configmaps"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().ConfigMaps().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("endpoints"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Endpoints().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("events"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Events().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("limitranges"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().LimitRanges().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("namespaces"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Namespaces().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("nodes"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Nodes().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("persistentvolumes"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().PersistentVolumes().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("persistentvolumeclaims"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().PersistentVolumeClaims().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("pods"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Pods().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("podtemplates"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().PodTemplates().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("replicationcontrollers"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().ReplicationControllers().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("resourcequotas"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().ResourceQuotas().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("secrets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Secrets().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("services"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().Services().Informer()}, nil
-	case api_v1.SchemeGroupVersion.WithResource("serviceaccounts"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Core().V1().ServiceAccounts().Informer()}, nil
-
-		// Group=Extensions, Version=V1beta1
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("daemonsets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().DaemonSets().Informer()}, nil
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("deployments"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().Deployments().Informer()}, nil
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("ingresses"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().Ingresses().Informer()}, nil
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("podsecuritypolicies"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().PodSecurityPolicies().Informer()}, nil
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("replicasets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().ReplicaSets().Informer()}, nil
-	case extensions_v1beta1.SchemeGroupVersion.WithResource("thirdpartyresources"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Extensions().V1beta1().ThirdPartyResources().Informer()}, nil
-
-		// Group=Policy, Version=V1beta1
-	case policy_v1beta1.SchemeGroupVersion.WithResource("poddisruptionbudgets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Policy().V1beta1().PodDisruptionBudgets().Informer()}, nil
-
-		// Group=Rbac, Version=V1alpha1
-	case v1alpha1.SchemeGroupVersion.WithResource("clusterroles"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().ClusterRoles().Informer()}, nil
-	case v1alpha1.SchemeGroupVersion.WithResource("clusterrolebindings"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().ClusterRoleBindings().Informer()}, nil
-	case v1alpha1.SchemeGroupVersion.WithResource("roles"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().Roles().Informer()}, nil
-	case v1alpha1.SchemeGroupVersion.WithResource("rolebindings"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1alpha1().RoleBindings().Informer()}, nil
-
-		// Group=Rbac, Version=V1beta1
-	case rbac_v1beta1.SchemeGroupVersion.WithResource("clusterroles"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1beta1().ClusterRoles().Informer()}, nil
-	case rbac_v1beta1.SchemeGroupVersion.WithResource("clusterrolebindings"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1beta1().ClusterRoleBindings().Informer()}, nil
-	case rbac_v1beta1.SchemeGroupVersion.WithResource("roles"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1beta1().Roles().Informer()}, nil
-	case rbac_v1beta1.SchemeGroupVersion.WithResource("rolebindings"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Rbac().V1beta1().RoleBindings().Informer()}, nil
-
-		// Group=Settings, Version=V1alpha1
-	case settings_v1alpha1.SchemeGroupVersion.WithResource("podpresets"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Settings().V1alpha1().PodPresets().Informer()}, nil
-
-		// Group=Storage, Version=V1
-	case storage_v1.SchemeGroupVersion.WithResource("storageclasses"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Storage().V1().StorageClasses().Informer()}, nil
-
-		// Group=Storage, Version=V1beta1
-	case storage_v1beta1.SchemeGroupVersion.WithResource("storageclasses"):
-		return &genericInformer{resource: resource.GroupResource(), informer: f.Storage().V1beta1().StorageClasses().Informer()}, nil
-
-	}
-
-	return nil, fmt.Errorf("no informer found for %v", resource)
-}
--- a/informers/internalinterfaces/factory_interfaces.go
+++ b/informers/internalinterfaces/factory_interfaces.go
@@ -1,34 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package internalinterfaces
-
-import (
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	kubernetes "k8s.io/client-go/kubernetes"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-type NewInformerFunc func(kubernetes.Interface, time.Duration) cache.SharedIndexInformer
-
-// SharedInformerFactory a small interface to allow for adding an informer without an import cycle
-type SharedInformerFactory interface {
-	Start(stopCh <-chan struct{})
-	InformerFor(obj runtime.Object, newFunc NewInformerFunc) cache.SharedIndexInformer
-}
--- a/informers/policy/interface.go
+++ b/informers/policy/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package policy
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	v1beta1 "k8s.io/client-go/informers/policy/v1beta1"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/policy/v1beta1/interface.go
+++ b/informers/policy/v1beta1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// PodDisruptionBudgets returns a PodDisruptionBudgetInformer.
-	PodDisruptionBudgets() PodDisruptionBudgetInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// PodDisruptionBudgets returns a PodDisruptionBudgetInformer.
-func (v *version) PodDisruptionBudgets() PodDisruptionBudgetInformer {
-	return &podDisruptionBudgetInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/policy/v1beta1/poddisruptionbudget.go
+++ b/informers/policy/v1beta1/poddisruptionbudget.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/policy/v1beta1"
-	policy_v1beta1 "k8s.io/client-go/pkg/apis/policy/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PodDisruptionBudgetInformer provides access to a shared informer and lister for
-// PodDisruptionBudgets.
-type PodDisruptionBudgetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.PodDisruptionBudgetLister
-}
-
-type podDisruptionBudgetInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPodDisruptionBudgetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.PolicyV1beta1().PodDisruptionBudgets(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.PolicyV1beta1().PodDisruptionBudgets(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&policy_v1beta1.PodDisruptionBudget{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *podDisruptionBudgetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&policy_v1beta1.PodDisruptionBudget{}, newPodDisruptionBudgetInformer)
-}
-
-func (f *podDisruptionBudgetInformer) Lister() v1beta1.PodDisruptionBudgetLister {
-	return v1beta1.NewPodDisruptionBudgetLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/interface.go
+++ b/informers/rbac/interface.go
@@ -1,52 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package rbac
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	v1alpha1 "k8s.io/client-go/informers/rbac/v1alpha1"
-	v1beta1 "k8s.io/client-go/informers/rbac/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 {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1alpha1 returns a new v1alpha1.Interface.
-func (g *group) V1alpha1() v1alpha1.Interface {
-	return v1alpha1.New(g.SharedInformerFactory)
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/rbac/v1alpha1/clusterrole.go
+++ b/informers/rbac/v1alpha1/clusterrole.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	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"
-	v1alpha1 "k8s.io/client-go/listers/rbac/v1alpha1"
-	rbac_v1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ClusterRoleInformer provides access to a shared informer and lister for
-// ClusterRoles.
-type ClusterRoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.ClusterRoleLister
-}
-
-type clusterRoleInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newClusterRoleInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1alpha1().ClusterRoles().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1alpha1().ClusterRoles().Watch(options)
-			},
-		},
-		&rbac_v1alpha1.ClusterRole{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *clusterRoleInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1alpha1.ClusterRole{}, newClusterRoleInformer)
-}
-
-func (f *clusterRoleInformer) Lister() v1alpha1.ClusterRoleLister {
-	return v1alpha1.NewClusterRoleLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1alpha1/clusterrolebinding.go
+++ b/informers/rbac/v1alpha1/clusterrolebinding.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	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"
-	v1alpha1 "k8s.io/client-go/listers/rbac/v1alpha1"
-	rbac_v1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ClusterRoleBindingInformer provides access to a shared informer and lister for
-// ClusterRoleBindings.
-type ClusterRoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.ClusterRoleBindingLister
-}
-
-type clusterRoleBindingInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newClusterRoleBindingInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1alpha1().ClusterRoleBindings().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1alpha1().ClusterRoleBindings().Watch(options)
-			},
-		},
-		&rbac_v1alpha1.ClusterRoleBinding{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *clusterRoleBindingInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1alpha1.ClusterRoleBinding{}, newClusterRoleBindingInformer)
-}
-
-func (f *clusterRoleBindingInformer) Lister() v1alpha1.ClusterRoleBindingLister {
-	return v1alpha1.NewClusterRoleBindingLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1alpha1/interface.go
+++ b/informers/rbac/v1alpha1/interface.go
@@ -1,64 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// ClusterRoles returns a ClusterRoleInformer.
-	ClusterRoles() ClusterRoleInformer
-	// ClusterRoleBindings returns a ClusterRoleBindingInformer.
-	ClusterRoleBindings() ClusterRoleBindingInformer
-	// Roles returns a RoleInformer.
-	Roles() RoleInformer
-	// RoleBindings returns a RoleBindingInformer.
-	RoleBindings() RoleBindingInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// ClusterRoles returns a ClusterRoleInformer.
-func (v *version) ClusterRoles() ClusterRoleInformer {
-	return &clusterRoleInformer{factory: v.SharedInformerFactory}
-}
-
-// ClusterRoleBindings returns a ClusterRoleBindingInformer.
-func (v *version) ClusterRoleBindings() ClusterRoleBindingInformer {
-	return &clusterRoleBindingInformer{factory: v.SharedInformerFactory}
-}
-
-// Roles returns a RoleInformer.
-func (v *version) Roles() RoleInformer {
-	return &roleInformer{factory: v.SharedInformerFactory}
-}
-
-// RoleBindings returns a RoleBindingInformer.
-func (v *version) RoleBindings() RoleBindingInformer {
-	return &roleBindingInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/rbac/v1alpha1/role.go
+++ b/informers/rbac/v1alpha1/role.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	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"
-	v1alpha1 "k8s.io/client-go/listers/rbac/v1alpha1"
-	rbac_v1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// RoleInformer provides access to a shared informer and lister for
-// Roles.
-type RoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.RoleLister
-}
-
-type roleInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newRoleInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1alpha1().Roles(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1alpha1().Roles(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&rbac_v1alpha1.Role{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *roleInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1alpha1.Role{}, newRoleInformer)
-}
-
-func (f *roleInformer) Lister() v1alpha1.RoleLister {
-	return v1alpha1.NewRoleLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1alpha1/rolebinding.go
+++ b/informers/rbac/v1alpha1/rolebinding.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	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"
-	v1alpha1 "k8s.io/client-go/listers/rbac/v1alpha1"
-	rbac_v1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// RoleBindingInformer provides access to a shared informer and lister for
-// RoleBindings.
-type RoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.RoleBindingLister
-}
-
-type roleBindingInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newRoleBindingInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1alpha1().RoleBindings(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1alpha1().RoleBindings(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&rbac_v1alpha1.RoleBinding{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *roleBindingInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1alpha1.RoleBinding{}, newRoleBindingInformer)
-}
-
-func (f *roleBindingInformer) Lister() v1alpha1.RoleBindingLister {
-	return v1alpha1.NewRoleBindingLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1beta1/clusterrole.go
+++ b/informers/rbac/v1beta1/clusterrole.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/rbac/v1beta1"
-	rbac_v1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ClusterRoleInformer provides access to a shared informer and lister for
-// ClusterRoles.
-type ClusterRoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.ClusterRoleLister
-}
-
-type clusterRoleInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newClusterRoleInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1beta1().ClusterRoles().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1beta1().ClusterRoles().Watch(options)
-			},
-		},
-		&rbac_v1beta1.ClusterRole{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *clusterRoleInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1beta1.ClusterRole{}, newClusterRoleInformer)
-}
-
-func (f *clusterRoleInformer) Lister() v1beta1.ClusterRoleLister {
-	return v1beta1.NewClusterRoleLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1beta1/clusterrolebinding.go
+++ b/informers/rbac/v1beta1/clusterrolebinding.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/rbac/v1beta1"
-	rbac_v1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// ClusterRoleBindingInformer provides access to a shared informer and lister for
-// ClusterRoleBindings.
-type ClusterRoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.ClusterRoleBindingLister
-}
-
-type clusterRoleBindingInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newClusterRoleBindingInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1beta1().ClusterRoleBindings().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1beta1().ClusterRoleBindings().Watch(options)
-			},
-		},
-		&rbac_v1beta1.ClusterRoleBinding{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *clusterRoleBindingInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1beta1.ClusterRoleBinding{}, newClusterRoleBindingInformer)
-}
-
-func (f *clusterRoleBindingInformer) Lister() v1beta1.ClusterRoleBindingLister {
-	return v1beta1.NewClusterRoleBindingLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1beta1/interface.go
+++ b/informers/rbac/v1beta1/interface.go
@@ -1,64 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// ClusterRoles returns a ClusterRoleInformer.
-	ClusterRoles() ClusterRoleInformer
-	// ClusterRoleBindings returns a ClusterRoleBindingInformer.
-	ClusterRoleBindings() ClusterRoleBindingInformer
-	// Roles returns a RoleInformer.
-	Roles() RoleInformer
-	// RoleBindings returns a RoleBindingInformer.
-	RoleBindings() RoleBindingInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// ClusterRoles returns a ClusterRoleInformer.
-func (v *version) ClusterRoles() ClusterRoleInformer {
-	return &clusterRoleInformer{factory: v.SharedInformerFactory}
-}
-
-// ClusterRoleBindings returns a ClusterRoleBindingInformer.
-func (v *version) ClusterRoleBindings() ClusterRoleBindingInformer {
-	return &clusterRoleBindingInformer{factory: v.SharedInformerFactory}
-}
-
-// Roles returns a RoleInformer.
-func (v *version) Roles() RoleInformer {
-	return &roleInformer{factory: v.SharedInformerFactory}
-}
-
-// RoleBindings returns a RoleBindingInformer.
-func (v *version) RoleBindings() RoleBindingInformer {
-	return &roleBindingInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/rbac/v1beta1/role.go
+++ b/informers/rbac/v1beta1/role.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/rbac/v1beta1"
-	rbac_v1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// RoleInformer provides access to a shared informer and lister for
-// Roles.
-type RoleInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.RoleLister
-}
-
-type roleInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newRoleInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1beta1().Roles(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1beta1().Roles(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&rbac_v1beta1.Role{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *roleInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1beta1.Role{}, newRoleInformer)
-}
-
-func (f *roleInformer) Lister() v1beta1.RoleLister {
-	return v1beta1.NewRoleLister(f.Informer().GetIndexer())
-}
--- a/informers/rbac/v1beta1/rolebinding.go
+++ b/informers/rbac/v1beta1/rolebinding.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/rbac/v1beta1"
-	rbac_v1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// RoleBindingInformer provides access to a shared informer and lister for
-// RoleBindings.
-type RoleBindingInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.RoleBindingLister
-}
-
-type roleBindingInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newRoleBindingInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.RbacV1beta1().RoleBindings(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.RbacV1beta1().RoleBindings(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&rbac_v1beta1.RoleBinding{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *roleBindingInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&rbac_v1beta1.RoleBinding{}, newRoleBindingInformer)
-}
-
-func (f *roleBindingInformer) Lister() v1beta1.RoleBindingLister {
-	return v1beta1.NewRoleBindingLister(f.Informer().GetIndexer())
-}
--- a/informers/settings/interface.go
+++ b/informers/settings/interface.go
@@ -1,44 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package settings
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	v1alpha1 "k8s.io/client-go/informers/settings/v1alpha1"
-)
-
-// 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
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1alpha1 returns a new v1alpha1.Interface.
-func (g *group) V1alpha1() v1alpha1.Interface {
-	return v1alpha1.New(g.SharedInformerFactory)
-}
--- a/informers/settings/v1alpha1/interface.go
+++ b/informers/settings/v1alpha1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// PodPresets returns a PodPresetInformer.
-	PodPresets() PodPresetInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// PodPresets returns a PodPresetInformer.
-func (v *version) PodPresets() PodPresetInformer {
-	return &podPresetInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/settings/v1alpha1/podpreset.go
+++ b/informers/settings/v1alpha1/podpreset.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1alpha1
-
-import (
-	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"
-	v1alpha1 "k8s.io/client-go/listers/settings/v1alpha1"
-	settings_v1alpha1 "k8s.io/client-go/pkg/apis/settings/v1alpha1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// PodPresetInformer provides access to a shared informer and lister for
-// PodPresets.
-type PodPresetInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1alpha1.PodPresetLister
-}
-
-type podPresetInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newPodPresetInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.SettingsV1alpha1().PodPresets(v1.NamespaceAll).List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.SettingsV1alpha1().PodPresets(v1.NamespaceAll).Watch(options)
-			},
-		},
-		&settings_v1alpha1.PodPreset{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *podPresetInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&settings_v1alpha1.PodPreset{}, newPodPresetInformer)
-}
-
-func (f *podPresetInformer) Lister() v1alpha1.PodPresetLister {
-	return v1alpha1.NewPodPresetLister(f.Informer().GetIndexer())
-}
--- a/informers/storage/interface.go
+++ b/informers/storage/interface.go
@@ -1,52 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package storage
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-	v1 "k8s.io/client-go/informers/storage/v1"
-	v1beta1 "k8s.io/client-go/informers/storage/v1beta1"
-)
-
-// Interface provides access to each of this group's versions.
-type Interface interface {
-	// V1 provides access to shared informers for resources in V1.
-	V1() v1.Interface
-	// V1beta1 provides access to shared informers for resources in V1beta1.
-	V1beta1() v1beta1.Interface
-}
-
-type group struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &group{f}
-}
-
-// V1 returns a new v1.Interface.
-func (g *group) V1() v1.Interface {
-	return v1.New(g.SharedInformerFactory)
-}
-
-// V1beta1 returns a new v1beta1.Interface.
-func (g *group) V1beta1() v1beta1.Interface {
-	return v1beta1.New(g.SharedInformerFactory)
-}
--- a/informers/storage/v1/interface.go
+++ b/informers/storage/v1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// StorageClasses returns a StorageClassInformer.
-	StorageClasses() StorageClassInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// StorageClasses returns a StorageClassInformer.
-func (v *version) StorageClasses() StorageClassInformer {
-	return &storageClassInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/storage/v1/storageclass.go
+++ b/informers/storage/v1/storageclass.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1
-
-import (
-	meta_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"
-	v1 "k8s.io/client-go/listers/storage/v1"
-	storage_v1 "k8s.io/client-go/pkg/apis/storage/v1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// StorageClassInformer provides access to a shared informer and lister for
-// StorageClasses.
-type StorageClassInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1.StorageClassLister
-}
-
-type storageClassInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newStorageClassInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options meta_v1.ListOptions) (runtime.Object, error) {
-				return client.StorageV1().StorageClasses().List(options)
-			},
-			WatchFunc: func(options meta_v1.ListOptions) (watch.Interface, error) {
-				return client.StorageV1().StorageClasses().Watch(options)
-			},
-		},
-		&storage_v1.StorageClass{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *storageClassInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&storage_v1.StorageClass{}, newStorageClassInformer)
-}
-
-func (f *storageClassInformer) Lister() v1.StorageClassLister {
-	return v1.NewStorageClassLister(f.Informer().GetIndexer())
-}
--- a/informers/storage/v1beta1/interface.go
+++ b/informers/storage/v1beta1/interface.go
@@ -1,43 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	internalinterfaces "k8s.io/client-go/informers/internalinterfaces"
-)
-
-// Interface provides access to all the informers in this group version.
-type Interface interface {
-	// StorageClasses returns a StorageClassInformer.
-	StorageClasses() StorageClassInformer
-}
-
-type version struct {
-	internalinterfaces.SharedInformerFactory
-}
-
-// New returns a new Interface.
-func New(f internalinterfaces.SharedInformerFactory) Interface {
-	return &version{f}
-}
-
-// StorageClasses returns a StorageClassInformer.
-func (v *version) StorageClasses() StorageClassInformer {
-	return &storageClassInformer{factory: v.SharedInformerFactory}
-}
--- a/informers/storage/v1beta1/storageclass.go
+++ b/informers/storage/v1beta1/storageclass.go
@@ -1,68 +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.
-*/
-
-// This file was automatically generated by informer-gen
-
-package v1beta1
-
-import (
-	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/storage/v1beta1"
-	storage_v1beta1 "k8s.io/client-go/pkg/apis/storage/v1beta1"
-	cache "k8s.io/client-go/tools/cache"
-	time "time"
-)
-
-// StorageClassInformer provides access to a shared informer and lister for
-// StorageClasses.
-type StorageClassInformer interface {
-	Informer() cache.SharedIndexInformer
-	Lister() v1beta1.StorageClassLister
-}
-
-type storageClassInformer struct {
-	factory internalinterfaces.SharedInformerFactory
-}
-
-func newStorageClassInformer(client kubernetes.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer {
-	sharedIndexInformer := cache.NewSharedIndexInformer(
-		&cache.ListWatch{
-			ListFunc: func(options v1.ListOptions) (runtime.Object, error) {
-				return client.StorageV1beta1().StorageClasses().List(options)
-			},
-			WatchFunc: func(options v1.ListOptions) (watch.Interface, error) {
-				return client.StorageV1beta1().StorageClasses().Watch(options)
-			},
-		},
-		&storage_v1beta1.StorageClass{},
-		resyncPeriod,
-		cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc},
-	)
-
-	return sharedIndexInformer
-}
-
-func (f *storageClassInformer) Informer() cache.SharedIndexInformer {
-	return f.factory.InformerFor(&storage_v1beta1.StorageClass{}, newStorageClassInformer)
-}
-
-func (f *storageClassInformer) Lister() v1beta1.StorageClassLister {
-	return v1beta1.NewStorageClassLister(f.Informer().GetIndexer())
-}
--- a/kubernetes/clientset.go
+++ b/kubernetes/clientset.go
@@ -17,102 +17,84 @@ limitations under the License.
 package kubernetes

 import (
-	glog "github.com/golang/glog"
+	"github.com/golang/glog"
 	discovery "k8s.io/client-go/discovery"
-	appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
-	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
-	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
-	authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
-	authorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
-	autoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
-	autoscalingv2alpha1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2alpha1"
-	batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1"
-	batchv2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
-	certificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
-	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
-	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
-	policyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
-	rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
-	rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
-	settingsv1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1"
-	storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1"
-	storagev1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
+	v1beta1apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
+	v1beta1authentication "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
+	v1beta1authorization "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
+	v1autoscaling "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
+	v1batch "k8s.io/client-go/kubernetes/typed/batch/v1"
+	v2alpha1batch "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
+	v1alpha1certificates "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	v1beta1extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	v1beta1policy "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
+	v1alpha1rbac "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
+	v1beta1storage "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
+	"k8s.io/client-go/pkg/util/flowcontrol"
+	_ "k8s.io/client-go/plugin/pkg/client/auth"
 	rest "k8s.io/client-go/rest"
-	flowcontrol "k8s.io/client-go/util/flowcontrol"
 )

 type Interface interface {
 	Discovery() discovery.DiscoveryInterface
-	CoreV1() corev1.CoreV1Interface
+	CoreV1() v1core.CoreV1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Core() corev1.CoreV1Interface
-	AppsV1beta1() appsv1beta1.AppsV1beta1Interface
+	Core() v1core.CoreV1Interface
+	AppsV1beta1() v1beta1apps.AppsV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Apps() appsv1beta1.AppsV1beta1Interface
-	AuthenticationV1() authenticationv1.AuthenticationV1Interface
+	Apps() v1beta1apps.AppsV1beta1Interface
+	AuthenticationV1beta1() v1beta1authentication.AuthenticationV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Authentication() authenticationv1.AuthenticationV1Interface
-	AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface
-	AuthorizationV1() authorizationv1.AuthorizationV1Interface
+	Authentication() v1beta1authentication.AuthenticationV1beta1Interface
+	AuthorizationV1beta1() v1beta1authorization.AuthorizationV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Authorization() authorizationv1.AuthorizationV1Interface
-	AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface
-	AutoscalingV1() autoscalingv1.AutoscalingV1Interface
+	Authorization() v1beta1authorization.AuthorizationV1beta1Interface
+	AutoscalingV1() v1autoscaling.AutoscalingV1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Autoscaling() autoscalingv1.AutoscalingV1Interface
-	AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface
-	BatchV1() batchv1.BatchV1Interface
+	Autoscaling() v1autoscaling.AutoscalingV1Interface
+	BatchV1() v1batch.BatchV1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Batch() batchv1.BatchV1Interface
-	BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface
-	CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface
+	Batch() v1batch.BatchV1Interface
+	BatchV2alpha1() v2alpha1batch.BatchV2alpha1Interface
+
+	CertificatesV1alpha1() v1alpha1certificates.CertificatesV1alpha1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Certificates() certificatesv1beta1.CertificatesV1beta1Interface
-	ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface
+	Certificates() v1alpha1certificates.CertificatesV1alpha1Interface
+	ExtensionsV1beta1() v1beta1extensions.ExtensionsV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Extensions() extensionsv1beta1.ExtensionsV1beta1Interface
-	PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface
+	Extensions() v1beta1extensions.ExtensionsV1beta1Interface
+	PolicyV1beta1() v1beta1policy.PolicyV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Policy() policyv1beta1.PolicyV1beta1Interface
-	RbacV1beta1() rbacv1beta1.RbacV1beta1Interface
+	Policy() v1beta1policy.PolicyV1beta1Interface
+	RbacV1alpha1() v1alpha1rbac.RbacV1alpha1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Rbac() rbacv1beta1.RbacV1beta1Interface
-	RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface
-	SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface
+	Rbac() v1alpha1rbac.RbacV1alpha1Interface
+	StorageV1beta1() v1beta1storage.StorageV1beta1Interface
 	// Deprecated: please explicitly pick a version if possible.
-	Settings() settingsv1alpha1.SettingsV1alpha1Interface
-	StorageV1beta1() storagev1beta1.StorageV1beta1Interface
-	StorageV1() storagev1.StorageV1Interface
-	// Deprecated: please explicitly pick a version if possible.
-	Storage() storagev1.StorageV1Interface
+	Storage() v1beta1storage.StorageV1beta1Interface
 }

 // Clientset contains the clients for groups. Each group has exactly one
 // version included in a Clientset.
 type Clientset struct {
 	*discovery.DiscoveryClient
-	*corev1.CoreV1Client
-	*appsv1beta1.AppsV1beta1Client
-	*authenticationv1.AuthenticationV1Client
-	*authenticationv1beta1.AuthenticationV1beta1Client
-	*authorizationv1.AuthorizationV1Client
-	*authorizationv1beta1.AuthorizationV1beta1Client
-	*autoscalingv1.AutoscalingV1Client
-	*autoscalingv2alpha1.AutoscalingV2alpha1Client
-	*batchv1.BatchV1Client
-	*batchv2alpha1.BatchV2alpha1Client
-	*certificatesv1beta1.CertificatesV1beta1Client
-	*extensionsv1beta1.ExtensionsV1beta1Client
-	*policyv1beta1.PolicyV1beta1Client
-	*rbacv1beta1.RbacV1beta1Client
-	*rbacv1alpha1.RbacV1alpha1Client
-	*settingsv1alpha1.SettingsV1alpha1Client
-	*storagev1beta1.StorageV1beta1Client
-	*storagev1.StorageV1Client
+	*v1core.CoreV1Client
+	*v1beta1apps.AppsV1beta1Client
+	*v1beta1authentication.AuthenticationV1beta1Client
+	*v1beta1authorization.AuthorizationV1beta1Client
+	*v1autoscaling.AutoscalingV1Client
+	*v1batch.BatchV1Client
+	*v2alpha1batch.BatchV2alpha1Client
+	*v1alpha1certificates.CertificatesV1alpha1Client
+	*v1beta1extensions.ExtensionsV1beta1Client
+	*v1beta1policy.PolicyV1beta1Client
+	*v1alpha1rbac.RbacV1alpha1Client
+	*v1beta1storage.StorageV1beta1Client
 }

 // CoreV1 retrieves the CoreV1Client
-func (c *Clientset) CoreV1() corev1.CoreV1Interface {
+func (c *Clientset) CoreV1() v1core.CoreV1Interface {
 	if c == nil {
 		return nil
 	}
@@ -121,7 +103,7 @@ func (c *Clientset) CoreV1() corev1.CoreV1Interface {

 // Deprecated: Core retrieves the default version of CoreClient.
 // Please explicitly pick a version.
-func (c *Clientset) Core() corev1.CoreV1Interface {
+func (c *Clientset) Core() v1core.CoreV1Interface {
 	if c == nil {
 		return nil
 	}
@@ -129,7 +111,7 @@ func (c *Clientset) Core() corev1.CoreV1Interface {
 }

 // AppsV1beta1 retrieves the AppsV1beta1Client
-func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
+func (c *Clientset) AppsV1beta1() v1beta1apps.AppsV1beta1Interface {
 	if c == nil {
 		return nil
 	}
@@ -138,57 +120,41 @@ func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {

 // Deprecated: Apps retrieves the default version of AppsClient.
 // Please explicitly pick a version.
-func (c *Clientset) Apps() appsv1beta1.AppsV1beta1Interface {
+func (c *Clientset) Apps() v1beta1apps.AppsV1beta1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.AppsV1beta1Client
 }

-// AuthenticationV1 retrieves the AuthenticationV1Client
-func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthenticationV1Client
-}
-
-// Deprecated: Authentication retrieves the default version of AuthenticationClient.
-// Please explicitly pick a version.
-func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthenticationV1Client
-}
-
 // AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client
-func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
+func (c *Clientset) AuthenticationV1beta1() v1beta1authentication.AuthenticationV1beta1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.AuthenticationV1beta1Client
 }

-// AuthorizationV1 retrieves the AuthorizationV1Client
-func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
+// Deprecated: Authentication retrieves the default version of AuthenticationClient.
+// Please explicitly pick a version.
+func (c *Clientset) Authentication() v1beta1authentication.AuthenticationV1beta1Interface {
 	if c == nil {
 		return nil
 	}
-	return c.AuthorizationV1Client
+	return c.AuthenticationV1beta1Client
+}
+
+// AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
+func (c *Clientset) AuthorizationV1beta1() v1beta1authorization.AuthorizationV1beta1Interface {
+	if c == nil {
+		return nil
+	}
+	return c.AuthorizationV1beta1Client
 }

 // Deprecated: Authorization retrieves the default version of AuthorizationClient.
 // Please explicitly pick a version.
-func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.AuthorizationV1Client
-}
-
-// AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
-func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
+func (c *Clientset) Authorization() v1beta1authorization.AuthorizationV1beta1Interface {
 	if c == nil {
 		return nil
 	}
@@ -196,7 +162,7 @@ func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1b
 }

 // AutoscalingV1 retrieves the AutoscalingV1Client
-func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
+func (c *Clientset) AutoscalingV1() v1autoscaling.AutoscalingV1Interface {
 	if c == nil {
 		return nil
 	}
@@ -205,23 +171,15 @@ func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {

 // Deprecated: Autoscaling retrieves the default version of AutoscalingClient.
 // Please explicitly pick a version.
-func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
+func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingV1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.AutoscalingV1Client
 }

-// AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client
-func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.AutoscalingV2alpha1Client
-}
-
 // BatchV1 retrieves the BatchV1Client
-func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
+func (c *Clientset) BatchV1() v1batch.BatchV1Interface {
 	if c == nil {
 		return nil
 	}
@@ -230,7 +188,7 @@ func (c *Clientset) BatchV1() batchv1.BatchV1Interface {

 // Deprecated: Batch retrieves the default version of BatchClient.
 // Please explicitly pick a version.
-func (c *Clientset) Batch() batchv1.BatchV1Interface {
+func (c *Clientset) Batch() v1batch.BatchV1Interface {
 	if c == nil {
 		return nil
 	}
@@ -238,32 +196,32 @@ func (c *Clientset) Batch() batchv1.BatchV1Interface {
 }

 // BatchV2alpha1 retrieves the BatchV2alpha1Client
-func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
+func (c *Clientset) BatchV2alpha1() v2alpha1batch.BatchV2alpha1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.BatchV2alpha1Client
 }

-// CertificatesV1beta1 retrieves the CertificatesV1beta1Client
-func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
+// CertificatesV1alpha1 retrieves the CertificatesV1alpha1Client
+func (c *Clientset) CertificatesV1alpha1() v1alpha1certificates.CertificatesV1alpha1Interface {
 	if c == nil {
 		return nil
 	}
-	return c.CertificatesV1beta1Client
+	return c.CertificatesV1alpha1Client
 }

 // Deprecated: Certificates retrieves the default version of CertificatesClient.
 // Please explicitly pick a version.
-func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface {
+func (c *Clientset) Certificates() v1alpha1certificates.CertificatesV1alpha1Interface {
 	if c == nil {
 		return nil
 	}
-	return c.CertificatesV1beta1Client
+	return c.CertificatesV1alpha1Client
 }

 // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
-func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
+func (c *Clientset) ExtensionsV1beta1() v1beta1extensions.ExtensionsV1beta1Interface {
 	if c == nil {
 		return nil
 	}
@@ -272,7 +230,7 @@ func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Inter

 // Deprecated: Extensions retrieves the default version of ExtensionsClient.
 // Please explicitly pick a version.
-func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
+func (c *Clientset) Extensions() v1beta1extensions.ExtensionsV1beta1Interface {
 	if c == nil {
 		return nil
 	}
@@ -280,7 +238,7 @@ func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
 }

 // PolicyV1beta1 retrieves the PolicyV1beta1Client
-func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
+func (c *Clientset) PolicyV1beta1() v1beta1policy.PolicyV1beta1Interface {
 	if c == nil {
 		return nil
 	}
@@ -289,85 +247,49 @@ func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {

 // Deprecated: Policy retrieves the default version of PolicyClient.
 // Please explicitly pick a version.
-func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface {
+func (c *Clientset) Policy() v1beta1policy.PolicyV1beta1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.PolicyV1beta1Client
 }

-// RbacV1beta1 retrieves the RbacV1beta1Client
-func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.RbacV1beta1Client
-}
-
-// Deprecated: Rbac retrieves the default version of RbacClient.
-// Please explicitly pick a version.
-func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.RbacV1beta1Client
-}
-
 // RbacV1alpha1 retrieves the RbacV1alpha1Client
-func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
+func (c *Clientset) RbacV1alpha1() v1alpha1rbac.RbacV1alpha1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.RbacV1alpha1Client
 }

-// SettingsV1alpha1 retrieves the SettingsV1alpha1Client
-func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.SettingsV1alpha1Client
-}
-
-// Deprecated: Settings retrieves the default version of SettingsClient.
+// Deprecated: Rbac retrieves the default version of RbacClient.
 // Please explicitly pick a version.
-func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface {
+func (c *Clientset) Rbac() v1alpha1rbac.RbacV1alpha1Interface {
 	if c == nil {
 		return nil
 	}
-	return c.SettingsV1alpha1Client
+	return c.RbacV1alpha1Client
 }

 // StorageV1beta1 retrieves the StorageV1beta1Client
-func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
+func (c *Clientset) StorageV1beta1() v1beta1storage.StorageV1beta1Interface {
 	if c == nil {
 		return nil
 	}
 	return c.StorageV1beta1Client
 }

-// StorageV1 retrieves the StorageV1Client
-func (c *Clientset) StorageV1() storagev1.StorageV1Interface {
-	if c == nil {
-		return nil
-	}
-	return c.StorageV1Client
-}
-
 // Deprecated: Storage retrieves the default version of StorageClient.
 // Please explicitly pick a version.
-func (c *Clientset) Storage() storagev1.StorageV1Interface {
+func (c *Clientset) Storage() v1beta1storage.StorageV1beta1Interface {
 	if c == nil {
 		return nil
 	}
-	return c.StorageV1Client
+	return c.StorageV1beta1Client
 }

 // Discovery retrieves the DiscoveryClient
 func (c *Clientset) Discovery() discovery.DiscoveryInterface {
-	if c == nil {
-		return nil
-	}
 	return c.DiscoveryClient
 }

@@ -377,138 +299,102 @@ func NewForConfig(c *rest.Config) (*Clientset, error) {
 	if configShallowCopy.RateLimiter == nil && configShallowCopy.QPS > 0 {
 		configShallowCopy.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(configShallowCopy.QPS, configShallowCopy.Burst)
 	}
-	var cs Clientset
+	var clientset Clientset
 	var err error
-	cs.CoreV1Client, err = corev1.NewForConfig(&configShallowCopy)
+	clientset.CoreV1Client, err = v1core.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AppsV1beta1Client, err = appsv1beta1.NewForConfig(&configShallowCopy)
+	clientset.AppsV1beta1Client, err = v1beta1apps.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthenticationV1Client, err = authenticationv1.NewForConfig(&configShallowCopy)
+	clientset.AuthenticationV1beta1Client, err = v1beta1authentication.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthenticationV1beta1Client, err = authenticationv1beta1.NewForConfig(&configShallowCopy)
+	clientset.AuthorizationV1beta1Client, err = v1beta1authorization.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthorizationV1Client, err = authorizationv1.NewForConfig(&configShallowCopy)
+	clientset.AutoscalingV1Client, err = v1autoscaling.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AuthorizationV1beta1Client, err = authorizationv1beta1.NewForConfig(&configShallowCopy)
+	clientset.BatchV1Client, err = v1batch.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AutoscalingV1Client, err = autoscalingv1.NewForConfig(&configShallowCopy)
+	clientset.BatchV2alpha1Client, err = v2alpha1batch.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.AutoscalingV2alpha1Client, err = autoscalingv2alpha1.NewForConfig(&configShallowCopy)
+	clientset.CertificatesV1alpha1Client, err = v1alpha1certificates.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchV1Client, err = batchv1.NewForConfig(&configShallowCopy)
+	clientset.ExtensionsV1beta1Client, err = v1beta1extensions.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.BatchV2alpha1Client, err = batchv2alpha1.NewForConfig(&configShallowCopy)
+	clientset.PolicyV1beta1Client, err = v1beta1policy.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.CertificatesV1beta1Client, err = certificatesv1beta1.NewForConfig(&configShallowCopy)
+	clientset.RbacV1alpha1Client, err = v1alpha1rbac.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}
-	cs.ExtensionsV1beta1Client, err = extensionsv1beta1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.PolicyV1beta1Client, err = policyv1beta1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.RbacV1beta1Client, err = rbacv1beta1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.RbacV1alpha1Client, err = rbacv1alpha1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.SettingsV1alpha1Client, err = settingsv1alpha1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.StorageV1beta1Client, err = storagev1beta1.NewForConfig(&configShallowCopy)
-	if err != nil {
-		return nil, err
-	}
-	cs.StorageV1Client, err = storagev1.NewForConfig(&configShallowCopy)
+	clientset.StorageV1beta1Client, err = v1beta1storage.NewForConfig(&configShallowCopy)
 	if err != nil {
 		return nil, err
 	}

-	cs.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
+	clientset.DiscoveryClient, err = discovery.NewDiscoveryClientForConfig(&configShallowCopy)
 	if err != nil {
 		glog.Errorf("failed to create the DiscoveryClient: %v", err)
 		return nil, err
 	}
-	return &cs, nil
+	return &clientset, nil
 }

 // NewForConfigOrDie creates a new Clientset for the given config and
 // panics if there is an error in the config.
 func NewForConfigOrDie(c *rest.Config) *Clientset {
-	var cs Clientset
-	cs.CoreV1Client = corev1.NewForConfigOrDie(c)
-	cs.AppsV1beta1Client = appsv1beta1.NewForConfigOrDie(c)
-	cs.AuthenticationV1Client = authenticationv1.NewForConfigOrDie(c)
-	cs.AuthenticationV1beta1Client = authenticationv1beta1.NewForConfigOrDie(c)
-	cs.AuthorizationV1Client = authorizationv1.NewForConfigOrDie(c)
-	cs.AuthorizationV1beta1Client = authorizationv1beta1.NewForConfigOrDie(c)
-	cs.AutoscalingV1Client = autoscalingv1.NewForConfigOrDie(c)
-	cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.NewForConfigOrDie(c)
-	cs.BatchV1Client = batchv1.NewForConfigOrDie(c)
-	cs.BatchV2alpha1Client = batchv2alpha1.NewForConfigOrDie(c)
-	cs.CertificatesV1beta1Client = certificatesv1beta1.NewForConfigOrDie(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.NewForConfigOrDie(c)
-	cs.PolicyV1beta1Client = policyv1beta1.NewForConfigOrDie(c)
-	cs.RbacV1beta1Client = rbacv1beta1.NewForConfigOrDie(c)
-	cs.RbacV1alpha1Client = rbacv1alpha1.NewForConfigOrDie(c)
-	cs.SettingsV1alpha1Client = settingsv1alpha1.NewForConfigOrDie(c)
-	cs.StorageV1beta1Client = storagev1beta1.NewForConfigOrDie(c)
-	cs.StorageV1Client = storagev1.NewForConfigOrDie(c)
+	var clientset Clientset
+	clientset.CoreV1Client = v1core.NewForConfigOrDie(c)
+	clientset.AppsV1beta1Client = v1beta1apps.NewForConfigOrDie(c)
+	clientset.AuthenticationV1beta1Client = v1beta1authentication.NewForConfigOrDie(c)
+	clientset.AuthorizationV1beta1Client = v1beta1authorization.NewForConfigOrDie(c)
+	clientset.AutoscalingV1Client = v1autoscaling.NewForConfigOrDie(c)
+	clientset.BatchV1Client = v1batch.NewForConfigOrDie(c)
+	clientset.BatchV2alpha1Client = v2alpha1batch.NewForConfigOrDie(c)
+	clientset.CertificatesV1alpha1Client = v1alpha1certificates.NewForConfigOrDie(c)
+	clientset.ExtensionsV1beta1Client = v1beta1extensions.NewForConfigOrDie(c)
+	clientset.PolicyV1beta1Client = v1beta1policy.NewForConfigOrDie(c)
+	clientset.RbacV1alpha1Client = v1alpha1rbac.NewForConfigOrDie(c)
+	clientset.StorageV1beta1Client = v1beta1storage.NewForConfigOrDie(c)

-	cs.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
-	return &cs
+	clientset.DiscoveryClient = discovery.NewDiscoveryClientForConfigOrDie(c)
+	return &clientset
 }

 // New creates a new Clientset for the given RESTClient.
 func New(c rest.Interface) *Clientset {
-	var cs Clientset
-	cs.CoreV1Client = corev1.New(c)
-	cs.AppsV1beta1Client = appsv1beta1.New(c)
-	cs.AuthenticationV1Client = authenticationv1.New(c)
-	cs.AuthenticationV1beta1Client = authenticationv1beta1.New(c)
-	cs.AuthorizationV1Client = authorizationv1.New(c)
-	cs.AuthorizationV1beta1Client = authorizationv1beta1.New(c)
-	cs.AutoscalingV1Client = autoscalingv1.New(c)
-	cs.AutoscalingV2alpha1Client = autoscalingv2alpha1.New(c)
-	cs.BatchV1Client = batchv1.New(c)
-	cs.BatchV2alpha1Client = batchv2alpha1.New(c)
-	cs.CertificatesV1beta1Client = certificatesv1beta1.New(c)
-	cs.ExtensionsV1beta1Client = extensionsv1beta1.New(c)
-	cs.PolicyV1beta1Client = policyv1beta1.New(c)
-	cs.RbacV1beta1Client = rbacv1beta1.New(c)
-	cs.RbacV1alpha1Client = rbacv1alpha1.New(c)
-	cs.SettingsV1alpha1Client = settingsv1alpha1.New(c)
-	cs.StorageV1beta1Client = storagev1beta1.New(c)
-	cs.StorageV1Client = storagev1.New(c)
+	var clientset Clientset
+	clientset.CoreV1Client = v1core.New(c)
+	clientset.AppsV1beta1Client = v1beta1apps.New(c)
+	clientset.AuthenticationV1beta1Client = v1beta1authentication.New(c)
+	clientset.AuthorizationV1beta1Client = v1beta1authorization.New(c)
+	clientset.AutoscalingV1Client = v1autoscaling.New(c)
+	clientset.BatchV1Client = v1batch.New(c)
+	clientset.BatchV2alpha1Client = v2alpha1batch.New(c)
+	clientset.CertificatesV1alpha1Client = v1alpha1certificates.New(c)
+	clientset.ExtensionsV1beta1Client = v1beta1extensions.New(c)
+	clientset.PolicyV1beta1Client = v1beta1policy.New(c)
+	clientset.RbacV1alpha1Client = v1alpha1rbac.New(c)
+	clientset.StorageV1beta1Client = v1beta1storage.New(c)

-	cs.DiscoveryClient = discovery.NewDiscoveryClient(c)
-	return &cs
+	clientset.DiscoveryClient = discovery.NewDiscoveryClient(c)
+	return &clientset
 }
--- a/kubernetes/doc.go
+++ b/kubernetes/doc.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-// This package is generated by client-gen with custom arguments.
+// This package is generated by client-gen with arguments: --clientset-name=release_1_5 --input=[api/v1,apps/v1beta1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,batch/v2alpha1,certificates/v1alpha1,extensions/v1beta1,policy/v1beta1,rbac/v1alpha1,storage/v1beta1]

 // This package has the automatically generated clientset.
 package kubernetes
--- a/kubernetes/fake/clientset_generated.go
+++ b/kubernetes/fake/clientset_generated.go
@@ -17,47 +17,37 @@ limitations under the License.
 package fake

 import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/discovery"
 	fakediscovery "k8s.io/client-go/discovery/fake"
-	kubernetes "k8s.io/client-go/kubernetes"
-	appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
-	fakeappsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1/fake"
-	authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1"
-	fakeauthenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1/fake"
-	authenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
-	fakeauthenticationv1beta1 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1/fake"
-	authorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1"
-	fakeauthorizationv1 "k8s.io/client-go/kubernetes/typed/authorization/v1/fake"
-	authorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
-	fakeauthorizationv1beta1 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1/fake"
-	autoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
-	fakeautoscalingv1 "k8s.io/client-go/kubernetes/typed/autoscaling/v1/fake"
-	autoscalingv2alpha1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2alpha1"
-	fakeautoscalingv2alpha1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2alpha1/fake"
-	batchv1 "k8s.io/client-go/kubernetes/typed/batch/v1"
-	fakebatchv1 "k8s.io/client-go/kubernetes/typed/batch/v1/fake"
-	batchv2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
-	fakebatchv2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1/fake"
-	certificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
-	fakecertificatesv1beta1 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1/fake"
-	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
-	fakecorev1 "k8s.io/client-go/kubernetes/typed/core/v1/fake"
-	extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
-	fakeextensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1/fake"
-	policyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
-	fakepolicyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1/fake"
-	rbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
-	fakerbacv1alpha1 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/fake"
-	rbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
-	fakerbacv1beta1 "k8s.io/client-go/kubernetes/typed/rbac/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"
-	fakestoragev1 "k8s.io/client-go/kubernetes/typed/storage/v1/fake"
-	storagev1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
-	fakestoragev1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1/fake"
+	clientset "k8s.io/client-go/kubernetes"
+	v1beta1apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
+	fakev1beta1apps "k8s.io/client-go/kubernetes/typed/apps/v1beta1/fake"
+	v1beta1authentication "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
+	fakev1beta1authentication "k8s.io/client-go/kubernetes/typed/authentication/v1beta1/fake"
+	v1beta1authorization "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
+	fakev1beta1authorization "k8s.io/client-go/kubernetes/typed/authorization/v1beta1/fake"
+	v1autoscaling "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
+	fakev1autoscaling "k8s.io/client-go/kubernetes/typed/autoscaling/v1/fake"
+	v1batch "k8s.io/client-go/kubernetes/typed/batch/v1"
+	fakev1batch "k8s.io/client-go/kubernetes/typed/batch/v1/fake"
+	v2alpha1batch "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
+	fakev2alpha1batch "k8s.io/client-go/kubernetes/typed/batch/v2alpha1/fake"
+	v1alpha1certificates "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1"
+	fakev1alpha1certificates "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1/fake"
+	v1core "k8s.io/client-go/kubernetes/typed/core/v1"
+	fakev1core "k8s.io/client-go/kubernetes/typed/core/v1/fake"
+	v1beta1extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
+	fakev1beta1extensions "k8s.io/client-go/kubernetes/typed/extensions/v1beta1/fake"
+	v1beta1policy "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
+	fakev1beta1policy "k8s.io/client-go/kubernetes/typed/policy/v1beta1/fake"
+	v1alpha1rbac "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
+	fakev1alpha1rbac "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1/fake"
+	v1beta1storage "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
+	fakev1beta1storage "k8s.io/client-go/kubernetes/typed/storage/v1beta1/fake"
+	"k8s.io/client-go/pkg/api"
+	"k8s.io/client-go/pkg/apimachinery/registered"
+	"k8s.io/client-go/pkg/runtime"
+	"k8s.io/client-go/pkg/watch"
 	"k8s.io/client-go/testing"
 )

@@ -66,7 +56,7 @@ import (
 // without applying any validations and/or defaults. It shouldn't be considered a replacement
 // for a real clientset and is mostly useful in simple unit tests.
 func NewSimpleClientset(objects ...runtime.Object) *Clientset {
-	o := testing.NewObjectTracker(registry, scheme, codecs.UniversalDecoder())
+	o := testing.NewObjectTracker(api.Scheme, api.Codecs.UniversalDecoder())
 	for _, obj := range objects {
 		if err := o.Add(obj); err != nil {
 			panic(err)
@@ -74,14 +64,14 @@ func NewSimpleClientset(objects ...runtime.Object) *Clientset {
 	}

 	fakePtr := testing.Fake{}
-	fakePtr.AddReactor("*", "*", testing.ObjectReaction(o, registry.RESTMapper()))
+	fakePtr.AddReactor("*", "*", testing.ObjectReaction(o, registered.RESTMapper()))

 	fakePtr.AddWatchReactor("*", testing.DefaultWatchReactor(watch.NewFake(), nil))

 	return &Clientset{fakePtr}
 }

-// Clientset implements kubernetes.Interface. Meant to be embedded into a
+// Clientset implements clientset.Interface. Meant to be embedded into a
 // struct to get a default implementation. This makes faking out just the method
 // you want to test easier.
 type Clientset struct {
@@ -92,154 +82,119 @@ func (c *Clientset) Discovery() discovery.DiscoveryInterface {
 	return &fakediscovery.FakeDiscovery{Fake: &c.Fake}
 }

-var _ kubernetes.Interface = &Clientset{}
+var _ clientset.Interface = &Clientset{}

 // CoreV1 retrieves the CoreV1Client
-func (c *Clientset) CoreV1() corev1.CoreV1Interface {
-	return &fakecorev1.FakeCoreV1{Fake: &c.Fake}
+func (c *Clientset) CoreV1() v1core.CoreV1Interface {
+	return &fakev1core.FakeCoreV1{Fake: &c.Fake}
 }

 // Core retrieves the CoreV1Client
-func (c *Clientset) Core() corev1.CoreV1Interface {
-	return &fakecorev1.FakeCoreV1{Fake: &c.Fake}
+func (c *Clientset) Core() v1core.CoreV1Interface {
+	return &fakev1core.FakeCoreV1{Fake: &c.Fake}
 }

 // AppsV1beta1 retrieves the AppsV1beta1Client
-func (c *Clientset) AppsV1beta1() appsv1beta1.AppsV1beta1Interface {
-	return &fakeappsv1beta1.FakeAppsV1beta1{Fake: &c.Fake}
+func (c *Clientset) AppsV1beta1() v1beta1apps.AppsV1beta1Interface {
+	return &fakev1beta1apps.FakeAppsV1beta1{Fake: &c.Fake}
 }

 // Apps retrieves the AppsV1beta1Client
-func (c *Clientset) Apps() appsv1beta1.AppsV1beta1Interface {
-	return &fakeappsv1beta1.FakeAppsV1beta1{Fake: &c.Fake}
-}
-
-// AuthenticationV1 retrieves the AuthenticationV1Client
-func (c *Clientset) AuthenticationV1() authenticationv1.AuthenticationV1Interface {
-	return &fakeauthenticationv1.FakeAuthenticationV1{Fake: &c.Fake}
-}
-
-// Authentication retrieves the AuthenticationV1Client
-func (c *Clientset) Authentication() authenticationv1.AuthenticationV1Interface {
-	return &fakeauthenticationv1.FakeAuthenticationV1{Fake: &c.Fake}
+func (c *Clientset) Apps() v1beta1apps.AppsV1beta1Interface {
+	return &fakev1beta1apps.FakeAppsV1beta1{Fake: &c.Fake}
 }

 // AuthenticationV1beta1 retrieves the AuthenticationV1beta1Client
-func (c *Clientset) AuthenticationV1beta1() authenticationv1beta1.AuthenticationV1beta1Interface {
-	return &fakeauthenticationv1beta1.FakeAuthenticationV1beta1{Fake: &c.Fake}
+func (c *Clientset) AuthenticationV1beta1() v1beta1authentication.AuthenticationV1beta1Interface {
+	return &fakev1beta1authentication.FakeAuthenticationV1beta1{Fake: &c.Fake}
 }

-// AuthorizationV1 retrieves the AuthorizationV1Client
-func (c *Clientset) AuthorizationV1() authorizationv1.AuthorizationV1Interface {
-	return &fakeauthorizationv1.FakeAuthorizationV1{Fake: &c.Fake}
-}
-
-// Authorization retrieves the AuthorizationV1Client
-func (c *Clientset) Authorization() authorizationv1.AuthorizationV1Interface {
-	return &fakeauthorizationv1.FakeAuthorizationV1{Fake: &c.Fake}
+// Authentication retrieves the AuthenticationV1beta1Client
+func (c *Clientset) Authentication() v1beta1authentication.AuthenticationV1beta1Interface {
+	return &fakev1beta1authentication.FakeAuthenticationV1beta1{Fake: &c.Fake}
 }

 // AuthorizationV1beta1 retrieves the AuthorizationV1beta1Client
-func (c *Clientset) AuthorizationV1beta1() authorizationv1beta1.AuthorizationV1beta1Interface {
-	return &fakeauthorizationv1beta1.FakeAuthorizationV1beta1{Fake: &c.Fake}
+func (c *Clientset) AuthorizationV1beta1() v1beta1authorization.AuthorizationV1beta1Interface {
+	return &fakev1beta1authorization.FakeAuthorizationV1beta1{Fake: &c.Fake}
+}
+
+// Authorization retrieves the AuthorizationV1beta1Client
+func (c *Clientset) Authorization() v1beta1authorization.AuthorizationV1beta1Interface {
+	return &fakev1beta1authorization.FakeAuthorizationV1beta1{Fake: &c.Fake}
 }

 // AutoscalingV1 retrieves the AutoscalingV1Client
-func (c *Clientset) AutoscalingV1() autoscalingv1.AutoscalingV1Interface {
-	return &fakeautoscalingv1.FakeAutoscalingV1{Fake: &c.Fake}
+func (c *Clientset) AutoscalingV1() v1autoscaling.AutoscalingV1Interface {
+	return &fakev1autoscaling.FakeAutoscalingV1{Fake: &c.Fake}
 }

 // Autoscaling retrieves the AutoscalingV1Client
-func (c *Clientset) Autoscaling() autoscalingv1.AutoscalingV1Interface {
-	return &fakeautoscalingv1.FakeAutoscalingV1{Fake: &c.Fake}
-}
-
-// AutoscalingV2alpha1 retrieves the AutoscalingV2alpha1Client
-func (c *Clientset) AutoscalingV2alpha1() autoscalingv2alpha1.AutoscalingV2alpha1Interface {
-	return &fakeautoscalingv2alpha1.FakeAutoscalingV2alpha1{Fake: &c.Fake}
+func (c *Clientset) Autoscaling() v1autoscaling.AutoscalingV1Interface {
+	return &fakev1autoscaling.FakeAutoscalingV1{Fake: &c.Fake}
 }

 // BatchV1 retrieves the BatchV1Client
-func (c *Clientset) BatchV1() batchv1.BatchV1Interface {
-	return &fakebatchv1.FakeBatchV1{Fake: &c.Fake}
+func (c *Clientset) BatchV1() v1batch.BatchV1Interface {
+	return &fakev1batch.FakeBatchV1{Fake: &c.Fake}
 }

 // Batch retrieves the BatchV1Client
-func (c *Clientset) Batch() batchv1.BatchV1Interface {
-	return &fakebatchv1.FakeBatchV1{Fake: &c.Fake}
+func (c *Clientset) Batch() v1batch.BatchV1Interface {
+	return &fakev1batch.FakeBatchV1{Fake: &c.Fake}
 }

 // BatchV2alpha1 retrieves the BatchV2alpha1Client
-func (c *Clientset) BatchV2alpha1() batchv2alpha1.BatchV2alpha1Interface {
-	return &fakebatchv2alpha1.FakeBatchV2alpha1{Fake: &c.Fake}
+func (c *Clientset) BatchV2alpha1() v2alpha1batch.BatchV2alpha1Interface {
+	return &fakev2alpha1batch.FakeBatchV2alpha1{Fake: &c.Fake}
 }

-// CertificatesV1beta1 retrieves the CertificatesV1beta1Client
-func (c *Clientset) CertificatesV1beta1() certificatesv1beta1.CertificatesV1beta1Interface {
-	return &fakecertificatesv1beta1.FakeCertificatesV1beta1{Fake: &c.Fake}
+// CertificatesV1alpha1 retrieves the CertificatesV1alpha1Client
+func (c *Clientset) CertificatesV1alpha1() v1alpha1certificates.CertificatesV1alpha1Interface {
+	return &fakev1alpha1certificates.FakeCertificatesV1alpha1{Fake: &c.Fake}
 }

-// Certificates retrieves the CertificatesV1beta1Client
-func (c *Clientset) Certificates() certificatesv1beta1.CertificatesV1beta1Interface {
-	return &fakecertificatesv1beta1.FakeCertificatesV1beta1{Fake: &c.Fake}
+// Certificates retrieves the CertificatesV1alpha1Client
+func (c *Clientset) Certificates() v1alpha1certificates.CertificatesV1alpha1Interface {
+	return &fakev1alpha1certificates.FakeCertificatesV1alpha1{Fake: &c.Fake}
 }

 // ExtensionsV1beta1 retrieves the ExtensionsV1beta1Client
-func (c *Clientset) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return &fakeextensionsv1beta1.FakeExtensionsV1beta1{Fake: &c.Fake}
+func (c *Clientset) ExtensionsV1beta1() v1beta1extensions.ExtensionsV1beta1Interface {
+	return &fakev1beta1extensions.FakeExtensionsV1beta1{Fake: &c.Fake}
 }

 // Extensions retrieves the ExtensionsV1beta1Client
-func (c *Clientset) Extensions() extensionsv1beta1.ExtensionsV1beta1Interface {
-	return &fakeextensionsv1beta1.FakeExtensionsV1beta1{Fake: &c.Fake}
+func (c *Clientset) Extensions() v1beta1extensions.ExtensionsV1beta1Interface {
+	return &fakev1beta1extensions.FakeExtensionsV1beta1{Fake: &c.Fake}
 }

 // PolicyV1beta1 retrieves the PolicyV1beta1Client
-func (c *Clientset) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface {
-	return &fakepolicyv1beta1.FakePolicyV1beta1{Fake: &c.Fake}
+func (c *Clientset) PolicyV1beta1() v1beta1policy.PolicyV1beta1Interface {
+	return &fakev1beta1policy.FakePolicyV1beta1{Fake: &c.Fake}
 }

 // Policy retrieves the PolicyV1beta1Client
-func (c *Clientset) Policy() policyv1beta1.PolicyV1beta1Interface {
-	return &fakepolicyv1beta1.FakePolicyV1beta1{Fake: &c.Fake}
-}
-
-// RbacV1beta1 retrieves the RbacV1beta1Client
-func (c *Clientset) RbacV1beta1() rbacv1beta1.RbacV1beta1Interface {
-	return &fakerbacv1beta1.FakeRbacV1beta1{Fake: &c.Fake}
-}
-
-// Rbac retrieves the RbacV1beta1Client
-func (c *Clientset) Rbac() rbacv1beta1.RbacV1beta1Interface {
-	return &fakerbacv1beta1.FakeRbacV1beta1{Fake: &c.Fake}
+func (c *Clientset) Policy() v1beta1policy.PolicyV1beta1Interface {
+	return &fakev1beta1policy.FakePolicyV1beta1{Fake: &c.Fake}
 }

 // RbacV1alpha1 retrieves the RbacV1alpha1Client
-func (c *Clientset) RbacV1alpha1() rbacv1alpha1.RbacV1alpha1Interface {
-	return &fakerbacv1alpha1.FakeRbacV1alpha1{Fake: &c.Fake}
+func (c *Clientset) RbacV1alpha1() v1alpha1rbac.RbacV1alpha1Interface {
+	return &fakev1alpha1rbac.FakeRbacV1alpha1{Fake: &c.Fake}
 }

-// SettingsV1alpha1 retrieves the SettingsV1alpha1Client
-func (c *Clientset) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface {
-	return &fakesettingsv1alpha1.FakeSettingsV1alpha1{Fake: &c.Fake}
-}
-
-// Settings retrieves the SettingsV1alpha1Client
-func (c *Clientset) Settings() settingsv1alpha1.SettingsV1alpha1Interface {
-	return &fakesettingsv1alpha1.FakeSettingsV1alpha1{Fake: &c.Fake}
+// Rbac retrieves the RbacV1alpha1Client
+func (c *Clientset) Rbac() v1alpha1rbac.RbacV1alpha1Interface {
+	return &fakev1alpha1rbac.FakeRbacV1alpha1{Fake: &c.Fake}
 }

 // StorageV1beta1 retrieves the StorageV1beta1Client
-func (c *Clientset) StorageV1beta1() storagev1beta1.StorageV1beta1Interface {
-	return &fakestoragev1beta1.FakeStorageV1beta1{Fake: &c.Fake}
+func (c *Clientset) StorageV1beta1() v1beta1storage.StorageV1beta1Interface {
+	return &fakev1beta1storage.FakeStorageV1beta1{Fake: &c.Fake}
 }

-// StorageV1 retrieves the StorageV1Client
-func (c *Clientset) StorageV1() storagev1.StorageV1Interface {
-	return &fakestoragev1.FakeStorageV1{Fake: &c.Fake}
-}
-
-// Storage retrieves the StorageV1Client
-func (c *Clientset) Storage() storagev1.StorageV1Interface {
-	return &fakestoragev1.FakeStorageV1{Fake: &c.Fake}
+// Storage retrieves the StorageV1beta1Client
+func (c *Clientset) Storage() v1beta1storage.StorageV1beta1Interface {
+	return &fakev1beta1storage.FakeStorageV1beta1{Fake: &c.Fake}
 }
--- a/kubernetes/fake/doc.go
+++ b/kubernetes/fake/doc.go
@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

-// This package is generated by client-gen with custom arguments.
+// This package is generated by client-gen with arguments: --clientset-name=release_1_5 --input=[api/v1,apps/v1beta1,authentication/v1beta1,authorization/v1beta1,autoscaling/v1,batch/v1,batch/v2alpha1,certificates/v1alpha1,extensions/v1beta1,policy/v1beta1,rbac/v1alpha1,storage/v1beta1]

 // This package has the automatically generated fake clientset.
 package fake
--- a/kubernetes/fake/register.go
+++ b/kubernetes/fake/register.go
@@ -1,68 +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
-
-import (
-	announced "k8s.io/apimachinery/pkg/apimachinery/announced"
-	registered "k8s.io/apimachinery/pkg/apimachinery/registered"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
-	core "k8s.io/client-go/pkg/api/install"
-	apps "k8s.io/client-go/pkg/apis/apps/install"
-	authentication "k8s.io/client-go/pkg/apis/authentication/install"
-	authorization "k8s.io/client-go/pkg/apis/authorization/install"
-	autoscaling "k8s.io/client-go/pkg/apis/autoscaling/install"
-	batch "k8s.io/client-go/pkg/apis/batch/install"
-	certificates "k8s.io/client-go/pkg/apis/certificates/install"
-	extensions "k8s.io/client-go/pkg/apis/extensions/install"
-	policy "k8s.io/client-go/pkg/apis/policy/install"
-	rbac "k8s.io/client-go/pkg/apis/rbac/install"
-	settings "k8s.io/client-go/pkg/apis/settings/install"
-	storage "k8s.io/client-go/pkg/apis/storage/install"
-	os "os"
-)
-
-var scheme = runtime.NewScheme()
-var codecs = serializer.NewCodecFactory(scheme)
-var parameterCodec = runtime.NewParameterCodec(scheme)
-
-var registry = registered.NewOrDie(os.Getenv("KUBE_API_VERSIONS"))
-var groupFactoryRegistry = make(announced.APIGroupFactoryRegistry)
-
-func init() {
-	v1.AddToGroupVersion(scheme, schema.GroupVersion{Version: "v1"})
-	Install(groupFactoryRegistry, registry, scheme)
-}
-
-// Install registers the API group and adds types to a scheme
-func Install(groupFactoryRegistry announced.APIGroupFactoryRegistry, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) {
-	core.Install(groupFactoryRegistry, registry, scheme)
-	apps.Install(groupFactoryRegistry, registry, scheme)
-	authentication.Install(groupFactoryRegistry, registry, scheme)
-	authorization.Install(groupFactoryRegistry, registry, scheme)
-	autoscaling.Install(groupFactoryRegistry, registry, scheme)
-	batch.Install(groupFactoryRegistry, registry, scheme)
-	certificates.Install(groupFactoryRegistry, registry, scheme)
-	extensions.Install(groupFactoryRegistry, registry, scheme)
-	policy.Install(groupFactoryRegistry, registry, scheme)
-	rbac.Install(groupFactoryRegistry, registry, scheme)
-	settings.Install(groupFactoryRegistry, registry, scheme)
-	storage.Install(groupFactoryRegistry, registry, scheme)
-
-}
--- a/kubernetes/import_known_versions.go
+++ b/kubernetes/import_known_versions.go
@@ -20,8 +20,8 @@ package kubernetes
 import (
 	"fmt"

-	"k8s.io/client-go/pkg/api"
 	_ "k8s.io/client-go/pkg/api/install"
+	"k8s.io/client-go/pkg/apimachinery/registered"
 	_ "k8s.io/client-go/pkg/apis/apps/install"
 	_ "k8s.io/client-go/pkg/apis/authentication/install"
 	_ "k8s.io/client-go/pkg/apis/authorization/install"
@@ -31,12 +31,11 @@ import (
 	_ "k8s.io/client-go/pkg/apis/extensions/install"
 	_ "k8s.io/client-go/pkg/apis/policy/install"
 	_ "k8s.io/client-go/pkg/apis/rbac/install"
-	_ "k8s.io/client-go/pkg/apis/settings/install"
 	_ "k8s.io/client-go/pkg/apis/storage/install"
 )

 func init() {
-	if missingVersions := api.Registry.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
+	if missingVersions := registered.ValidateEnvRequestedVersions(); len(missingVersions) != 0 {
 		panic(fmt.Sprintf("KUBE_API_VERSIONS contains versions that are not installed: %q.", missingVersions))
 	}
 }
--- a/kubernetes/scheme/register.go
+++ b/kubernetes/scheme/register.go
@@ -1,87 +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 scheme
-
-import (
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	runtime "k8s.io/apimachinery/pkg/runtime"
-	schema "k8s.io/apimachinery/pkg/runtime/schema"
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
-	corev1 "k8s.io/client-go/pkg/api/v1"
-	appsv1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
-	authenticationv1 "k8s.io/client-go/pkg/apis/authentication/v1"
-	authenticationv1beta1 "k8s.io/client-go/pkg/apis/authentication/v1beta1"
-	authorizationv1 "k8s.io/client-go/pkg/apis/authorization/v1"
-	authorizationv1beta1 "k8s.io/client-go/pkg/apis/authorization/v1beta1"
-	autoscalingv1 "k8s.io/client-go/pkg/apis/autoscaling/v1"
-	autoscalingv2alpha1 "k8s.io/client-go/pkg/apis/autoscaling/v2alpha1"
-	batchv1 "k8s.io/client-go/pkg/apis/batch/v1"
-	batchv2alpha1 "k8s.io/client-go/pkg/apis/batch/v2alpha1"
-	certificatesv1beta1 "k8s.io/client-go/pkg/apis/certificates/v1beta1"
-	extensionsv1beta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
-	policyv1beta1 "k8s.io/client-go/pkg/apis/policy/v1beta1"
-	rbacv1alpha1 "k8s.io/client-go/pkg/apis/rbac/v1alpha1"
-	rbacv1beta1 "k8s.io/client-go/pkg/apis/rbac/v1beta1"
-	settingsv1alpha1 "k8s.io/client-go/pkg/apis/settings/v1alpha1"
-	storagev1 "k8s.io/client-go/pkg/apis/storage/v1"
-	storagev1beta1 "k8s.io/client-go/pkg/apis/storage/v1beta1"
-)
-
-var Scheme = runtime.NewScheme()
-var Codecs = serializer.NewCodecFactory(Scheme)
-var ParameterCodec = runtime.NewParameterCodec(Scheme)
-
-func init() {
-	v1.AddToGroupVersion(Scheme, schema.GroupVersion{Version: "v1"})
-	AddToScheme(Scheme)
-}
-
-// AddToScheme adds all types of this clientset into the given scheme. This allows composition
-// of clientsets, like in:
-//
-//   import (
-//     "k8s.io/client-go/kubernetes"
-//     clientsetscheme "k8s.io/client-go/kuberentes/scheme"
-//     aggregatorclientsetscheme "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset/scheme"
-//   )
-//
-//   kclientset, _ := kubernetes.NewForConfig(c)
-//   aggregatorclientsetscheme.AddToScheme(clientsetscheme.Scheme)
-//
-// After this, RawExtensions in Kubernetes types will serialize kube-aggregator types
-// correctly.
-func AddToScheme(scheme *runtime.Scheme) {
-	corev1.AddToScheme(scheme)
-	appsv1beta1.AddToScheme(scheme)
-	authenticationv1.AddToScheme(scheme)
-	authenticationv1beta1.AddToScheme(scheme)
-	authorizationv1.AddToScheme(scheme)
-	authorizationv1beta1.AddToScheme(scheme)
-	autoscalingv1.AddToScheme(scheme)
-	autoscalingv2alpha1.AddToScheme(scheme)
-	batchv1.AddToScheme(scheme)
-	batchv2alpha1.AddToScheme(scheme)
-	certificatesv1beta1.AddToScheme(scheme)
-	extensionsv1beta1.AddToScheme(scheme)
-	policyv1beta1.AddToScheme(scheme)
-	rbacv1beta1.AddToScheme(scheme)
-	rbacv1alpha1.AddToScheme(scheme)
-	settingsv1alpha1.AddToScheme(scheme)
-	storagev1beta1.AddToScheme(scheme)
-	storagev1.AddToScheme(scheme)
-
-}
--- a/kubernetes/typed/apps/v1beta1/apps_client.go
+++ b/kubernetes/typed/apps/v1beta1/apps_client.go
@@ -17,32 +17,24 @@ limitations under the License.
 package v1beta1

 import (
-	serializer "k8s.io/apimachinery/pkg/runtime/serializer"
-	"k8s.io/client-go/kubernetes/scheme"
-	v1beta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	fmt "fmt"
+	api "k8s.io/client-go/pkg/api"
+	unversioned "k8s.io/client-go/pkg/api/unversioned"
+	registered "k8s.io/client-go/pkg/apimachinery/registered"
+	serializer "k8s.io/client-go/pkg/runtime/serializer"
 	rest "k8s.io/client-go/rest"
 )

 type AppsV1beta1Interface interface {
 	RESTClient() rest.Interface
-	DeploymentsGetter
-	ScalesGetter
 	StatefulSetsGetter
 }

-// AppsV1beta1Client is used to interact with features provided by the apps group.
+// AppsV1beta1Client is used to interact with features provided by the k8s.io/kubernetes/pkg/apimachinery/registered.Group group.
 type AppsV1beta1Client struct {
 	restClient rest.Interface
 }

-func (c *AppsV1beta1Client) Deployments(namespace string) DeploymentInterface {
-	return newDeployments(c, namespace)
-}
-
-func (c *AppsV1beta1Client) Scales(namespace string) ScaleInterface {
-	return newScales(c, namespace)
-}
-
 func (c *AppsV1beta1Client) StatefulSets(namespace string) StatefulSetInterface {
 	return newStatefulSets(c, namespace)
 }
@@ -76,14 +68,22 @@ func New(c rest.Interface) *AppsV1beta1Client {
 }

 func setConfigDefaults(config *rest.Config) error {
-	gv := v1beta1.SchemeGroupVersion
-	config.GroupVersion = &gv
+	gv, err := unversioned.ParseGroupVersion("apps/v1beta1")
+	if err != nil {
+		return err
+	}
+	// if apps/v1beta1 is not enabled, return an error
+	if !registered.IsEnabledVersion(gv) {
+		return fmt.Errorf("apps/v1beta1 is not enabled")
+	}
 	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
-
 	if config.UserAgent == "" {
 		config.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
+	copyGroupVersion := gv
+	config.GroupVersion = &copyGroupVersion
+
+	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: api.Codecs}

 	return nil
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Smith	e121606b0d	Merge pull request #102 from caesarxuchao/fix-release-2.0 manually update release-2.0	2017-02-13 09:46:50 -08:00
Chao Xu	3ac7cf0bf8	manually update release-2.0, tracking k8s.io/kubernetes release 1.5, last commit is bde8578d9675129b7a2aa08f1b825ec6cc0f3420	2017-02-12 20:21:49 -08:00
Chao Xu	0814629f26	Merge pull request #97 from caesarxuchao/release-2.0-travis Add travis	2017-02-11 05:45:52 -08:00
Chao Xu	582881bb0a	add travis	2017-02-11 05:37:14 -08:00
Kubernetes Publisher	724650ebfc	published by bot (https://github.com/kubernetes/test-infra/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch release-1.5, last commit is 92a03028433cdef51eb36a484c555e4c8900f727	2017-02-01 03:06:46 +00:00
Chao Xu	d81cb85237	Merge pull request #54 from caesarxuchao/release-2.0 Cherry-pick fixes to release 2.0	2016-12-19 22:23:22 -08:00
Daisuke Fujita	f53b36f856	Make third-party example buildable	2016-12-14 14:58:57 -08:00
Daisuke Fujita	1fa1950168	Make in-cluster example buildable	2016-12-14 14:58:57 -08:00
Daisuke Fujita	0d05577f3d	Make out-of-cluster example buildable	2016-12-14 14:58:57 -08:00
Kubernetes Publisher	47044f129a	published by bot (https://github.com/kubernetes/contrib/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch master, last commit is 800ef09dc19c04789c49c2e83e963bbd986cda7a	2016-12-14 14:58:09 -08:00
Will Farrington	2a26fffee3	Add README	2016-12-14 14:57:02 -08:00
Will Farrington	4cfa3441eb	Add an example for standard CRUD operations with ThirdPartyResources	2016-12-14 14:57:02 -08:00
Kubernetes Publisher	93f59dca8d	published by bot (https://github.com/kubernetes/contrib/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch master, last commit is 1bc5b822cd566321c115d4ebac5d97cfd347d687	2016-12-14 14:56:49 -08:00
Kubernetes Publisher	f672dd619e	published by bot (https://github.com/kubernetes/contrib/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch master, last commit is 8558768650b1da489aa63050bc03f1d42912c968	2016-12-14 14:56:49 -08:00
Kubernetes Publisher	a7e2e09688	published by bot (https://github.com/kubernetes/contrib/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch master, last commit is d1d8e428b14907b2cf67ba78cce2dae4c2fdf15b	2016-12-14 14:56:49 -08:00
Kubernetes Publisher	280a11dd85	published by bot (https://github.com/kubernetes/contrib/tree/master/mungegithub) copied from https://github.com/kubernetes/kubernetes.git, branch master, last commit is 66a7a1f961489b81e0357a6307270d50b00c5f50	2016-12-14 14:56:49 -08:00