move k8s deps into podman

We only need a small part of the k8s dependencies but they are the
biggest dependencies in podman by far. Moving them into podman allows us
to remove the unnecessary parts.

Signed-off-by: Paul Holzinger <pholzing@redhat.com>

25 files changed, 0 insertions, 5336 deletions

diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/codec.go b/vendor/k8s.io/apimachinery/pkg/runtime/codec.go
deleted file mode 100644
index a92863139..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/codec.go
+++ /dev/null
@@ -1,396 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/url"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"k8s.io/apimachinery/pkg/conversion/queryparams"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/klog/v2"
-)
-
-// codec binds an encoder and decoder.
-type codec struct {
-	Encoder
-	Decoder
-}
-
-// NewCodec creates a Codec from an Encoder and Decoder.
-func NewCodec(e Encoder, d Decoder) Codec {
-	return codec{e, d}
-}
-
-// Encode is a convenience wrapper for encoding to a []byte from an Encoder
-func Encode(e Encoder, obj Object) ([]byte, error) {
-	// TODO: reuse buffer
-	buf := &bytes.Buffer{}
-	if err := e.Encode(obj, buf); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-// Decode is a convenience wrapper for decoding data into an Object.
-func Decode(d Decoder, data []byte) (Object, error) {
-	obj, _, err := d.Decode(data, nil, nil)
-	return obj, err
-}
-
-// DecodeInto performs a Decode into the provided object.
-func DecodeInto(d Decoder, data []byte, into Object) error {
-	out, gvk, err := d.Decode(data, nil, into)
-	if err != nil {
-		return err
-	}
-	if out != into {
-		return fmt.Errorf("unable to decode %s into %v", gvk, reflect.TypeOf(into))
-	}
-	return nil
-}
-
-// EncodeOrDie is a version of Encode which will panic instead of returning an error. For tests.
-func EncodeOrDie(e Encoder, obj Object) string {
-	bytes, err := Encode(e, obj)
-	if err != nil {
-		panic(err)
-	}
-	return string(bytes)
-}
-
-// UseOrCreateObject returns obj if the canonical ObjectKind returned by the provided typer matches gvk, or
-// invokes the ObjectCreator to instantiate a new gvk. Returns an error if the typer cannot find the object.
-func UseOrCreateObject(t ObjectTyper, c ObjectCreater, gvk schema.GroupVersionKind, obj Object) (Object, error) {
-	if obj != nil {
-		kinds, _, err := t.ObjectKinds(obj)
-		if err != nil {
-			return nil, err
-		}
-		for _, kind := range kinds {
-			if gvk == kind {
-				return obj, nil
-			}
-		}
-	}
-	return c.New(gvk)
-}
-
-// NoopEncoder converts an Decoder to a Serializer or Codec for code that expects them but only uses decoding.
-type NoopEncoder struct {
-	Decoder
-}
-
-var _ Serializer = NoopEncoder{}
-
-const noopEncoderIdentifier Identifier = "noop"
-
-func (n NoopEncoder) Encode(obj Object, w io.Writer) error {
-	// There is no need to handle runtime.CacheableObject, as we don't
-	// process the obj at all.
-	return fmt.Errorf("encoding is not allowed for this codec: %v", reflect.TypeOf(n.Decoder))
-}
-
-// Identifier implements runtime.Encoder interface.
-func (n NoopEncoder) Identifier() Identifier {
-	return noopEncoderIdentifier
-}
-
-// NoopDecoder converts an Encoder to a Serializer or Codec for code that expects them but only uses encoding.
-type NoopDecoder struct {
-	Encoder
-}
-
-var _ Serializer = NoopDecoder{}
-
-func (n NoopDecoder) Decode(data []byte, gvk *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) {
-	return nil, nil, fmt.Errorf("decoding is not allowed for this codec: %v", reflect.TypeOf(n.Encoder))
-}
-
-// NewParameterCodec creates a ParameterCodec capable of transforming url values into versioned objects and back.
-func NewParameterCodec(scheme *Scheme) ParameterCodec {
-	return &parameterCodec{
-		typer:     scheme,
-		convertor: scheme,
-		creator:   scheme,
-		defaulter: scheme,
-	}
-}
-
-// parameterCodec implements conversion to and from query parameters and objects.
-type parameterCodec struct {
-	typer     ObjectTyper
-	convertor ObjectConvertor
-	creator   ObjectCreater
-	defaulter ObjectDefaulter
-}
-
-var _ ParameterCodec = &parameterCodec{}
-
-// DecodeParameters converts the provided url.Values into an object of type From with the kind of into, and then
-// converts that object to into (if necessary). Returns an error if the operation cannot be completed.
-func (c *parameterCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into Object) error {
-	if len(parameters) == 0 {
-		return nil
-	}
-	targetGVKs, _, err := c.typer.ObjectKinds(into)
-	if err != nil {
-		return err
-	}
-	for i := range targetGVKs {
-		if targetGVKs[i].GroupVersion() == from {
-			if err := c.convertor.Convert(&parameters, into, nil); err != nil {
-				return err
-			}
-			// in the case where we going into the same object we're receiving, default on the outbound object
-			if c.defaulter != nil {
-				c.defaulter.Default(into)
-			}
-			return nil
-		}
-	}
-
-	input, err := c.creator.New(from.WithKind(targetGVKs[0].Kind))
-	if err != nil {
-		return err
-	}
-	if err := c.convertor.Convert(&parameters, input, nil); err != nil {
-		return err
-	}
-	// if we have defaulter, default the input before converting to output
-	if c.defaulter != nil {
-		c.defaulter.Default(input)
-	}
-	return c.convertor.Convert(input, into, nil)
-}
-
-// EncodeParameters converts the provided object into the to version, then converts that object to url.Values.
-// Returns an error if conversion is not possible.
-func (c *parameterCodec) EncodeParameters(obj Object, to schema.GroupVersion) (url.Values, error) {
-	gvks, _, err := c.typer.ObjectKinds(obj)
-	if err != nil {
-		return nil, err
-	}
-	gvk := gvks[0]
-	if to != gvk.GroupVersion() {
-		out, err := c.convertor.ConvertToVersion(obj, to)
-		if err != nil {
-			return nil, err
-		}
-		obj = out
-	}
-	return queryparams.Convert(obj)
-}
-
-type base64Serializer struct {
-	Encoder
-	Decoder
-
-	identifier Identifier
-}
-
-func NewBase64Serializer(e Encoder, d Decoder) Serializer {
-	return &base64Serializer{
-		Encoder:    e,
-		Decoder:    d,
-		identifier: identifier(e),
-	}
-}
-
-func identifier(e Encoder) Identifier {
-	result := map[string]string{
-		"name": "base64",
-	}
-	if e != nil {
-		result["encoder"] = string(e.Identifier())
-	}
-	identifier, err := json.Marshal(result)
-	if err != nil {
-		klog.Fatalf("Failed marshaling identifier for base64Serializer: %v", err)
-	}
-	return Identifier(identifier)
-}
-
-func (s base64Serializer) Encode(obj Object, stream io.Writer) error {
-	if co, ok := obj.(CacheableObject); ok {
-		return co.CacheEncode(s.Identifier(), s.doEncode, stream)
-	}
-	return s.doEncode(obj, stream)
-}
-
-func (s base64Serializer) doEncode(obj Object, stream io.Writer) error {
-	e := base64.NewEncoder(base64.StdEncoding, stream)
-	err := s.Encoder.Encode(obj, e)
-	e.Close()
-	return err
-}
-
-// Identifier implements runtime.Encoder interface.
-func (s base64Serializer) Identifier() Identifier {
-	return s.identifier
-}
-
-func (s base64Serializer) Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) {
-	out := make([]byte, base64.StdEncoding.DecodedLen(len(data)))
-	n, err := base64.StdEncoding.Decode(out, data)
-	if err != nil {
-		return nil, nil, err
-	}
-	return s.Decoder.Decode(out[:n], defaults, into)
-}
-
-// SerializerInfoForMediaType returns the first info in types that has a matching media type (which cannot
-// include media-type parameters), or the first info with an empty media type, or false if no type matches.
-func SerializerInfoForMediaType(types []SerializerInfo, mediaType string) (SerializerInfo, bool) {
-	for _, info := range types {
-		if info.MediaType == mediaType {
-			return info, true
-		}
-	}
-	for _, info := range types {
-		if len(info.MediaType) == 0 {
-			return info, true
-		}
-	}
-	return SerializerInfo{}, false
-}
-
-var (
-	// InternalGroupVersioner will always prefer the internal version for a given group version kind.
-	InternalGroupVersioner GroupVersioner = internalGroupVersioner{}
-	// DisabledGroupVersioner will reject all kinds passed to it.
-	DisabledGroupVersioner GroupVersioner = disabledGroupVersioner{}
-)
-
-const (
-	internalGroupVersionerIdentifier = "internal"
-	disabledGroupVersionerIdentifier = "disabled"
-)
-
-type internalGroupVersioner struct{}
-
-// KindForGroupVersionKinds returns an internal Kind if one is found, or converts the first provided kind to the internal version.
-func (internalGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) {
-	for _, kind := range kinds {
-		if kind.Version == APIVersionInternal {
-			return kind, true
-		}
-	}
-	for _, kind := range kinds {
-		return schema.GroupVersionKind{Group: kind.Group, Version: APIVersionInternal, Kind: kind.Kind}, true
-	}
-	return schema.GroupVersionKind{}, false
-}
-
-// Identifier implements GroupVersioner interface.
-func (internalGroupVersioner) Identifier() string {
-	return internalGroupVersionerIdentifier
-}
-
-type disabledGroupVersioner struct{}
-
-// KindForGroupVersionKinds returns false for any input.
-func (disabledGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) {
-	return schema.GroupVersionKind{}, false
-}
-
-// Identifier implements GroupVersioner interface.
-func (disabledGroupVersioner) Identifier() string {
-	return disabledGroupVersionerIdentifier
-}
-
-// Assert that schema.GroupVersion and GroupVersions implement GroupVersioner
-var _ GroupVersioner = schema.GroupVersion{}
-var _ GroupVersioner = schema.GroupVersions{}
-var _ GroupVersioner = multiGroupVersioner{}
-
-type multiGroupVersioner struct {
-	target             schema.GroupVersion
-	acceptedGroupKinds []schema.GroupKind
-	coerce             bool
-}
-
-// NewMultiGroupVersioner returns the provided group version for any kind that matches one of the provided group kinds.
-// Kind may be empty in the provided group kind, in which case any kind will match.
-func NewMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner {
-	if len(groupKinds) == 0 || (len(groupKinds) == 1 && groupKinds[0].Group == gv.Group) {
-		return gv
-	}
-	return multiGroupVersioner{target: gv, acceptedGroupKinds: groupKinds}
-}
-
-// NewCoercingMultiGroupVersioner returns the provided group version for any incoming kind.
-// Incoming kinds that match the provided groupKinds are preferred.
-// Kind may be empty in the provided group kind, in which case any kind will match.
-// Examples:
-//   gv=mygroup/__internal, groupKinds=mygroup/Foo, anothergroup/Bar
-//   KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group/kind)
-//
-//   gv=mygroup/__internal, groupKinds=mygroup, anothergroup
-//   KindForGroupVersionKinds(yetanother/v1/Baz, anothergroup/v1/Bar) -> mygroup/__internal/Bar (matched preferred group)
-//
-//   gv=mygroup/__internal, groupKinds=mygroup, anothergroup
-//   KindForGroupVersionKinds(yetanother/v1/Baz, yetanother/v1/Bar) -> mygroup/__internal/Baz (no preferred group/kind match, uses first kind in list)
-func NewCoercingMultiGroupVersioner(gv schema.GroupVersion, groupKinds ...schema.GroupKind) GroupVersioner {
-	return multiGroupVersioner{target: gv, acceptedGroupKinds: groupKinds, coerce: true}
-}
-
-// KindForGroupVersionKinds returns the target group version if any kind matches any of the original group kinds. It will
-// use the originating kind where possible.
-func (v multiGroupVersioner) KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (schema.GroupVersionKind, bool) {
-	for _, src := range kinds {
-		for _, kind := range v.acceptedGroupKinds {
-			if kind.Group != src.Group {
-				continue
-			}
-			if len(kind.Kind) > 0 && kind.Kind != src.Kind {
-				continue
-			}
-			return v.target.WithKind(src.Kind), true
-		}
-	}
-	if v.coerce && len(kinds) > 0 {
-		return v.target.WithKind(kinds[0].Kind), true
-	}
-	return schema.GroupVersionKind{}, false
-}
-
-// Identifier implements GroupVersioner interface.
-func (v multiGroupVersioner) Identifier() string {
-	groupKinds := make([]string, 0, len(v.acceptedGroupKinds))
-	for _, gk := range v.acceptedGroupKinds {
-		groupKinds = append(groupKinds, gk.String())
-	}
-	result := map[string]string{
-		"name":     "multi",
-		"target":   v.target.String(),
-		"accepted": strings.Join(groupKinds, ","),
-		"coerce":   strconv.FormatBool(v.coerce),
-	}
-	identifier, err := json.Marshal(result)
-	if err != nil {
-		klog.Fatalf("Failed marshaling Identifier for %#v: %v", v, err)
-	}
-	return string(identifier)
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go b/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go
deleted file mode 100644
index 000228061..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/codec_check.go
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package runtime
-
-import (
-	"fmt"
-	"reflect"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/json"
-)
-
-// CheckCodec makes sure that the codec can encode objects like internalType,
-// decode all of the external types listed, and also decode them into the given
-// object. (Will modify internalObject.) (Assumes JSON serialization.)
-// TODO: verify that the correct external version is chosen on encode...
-func CheckCodec(c Codec, internalType Object, externalTypes ...schema.GroupVersionKind) error {
-	if _, err := Encode(c, internalType); err != nil {
-		return fmt.Errorf("Internal type not encodable: %v", err)
-	}
-	for _, et := range externalTypes {
-		typeMeta := TypeMeta{
-			Kind:       et.Kind,
-			APIVersion: et.GroupVersion().String(),
-		}
-		exBytes, err := json.Marshal(&typeMeta)
-		if err != nil {
-			return err
-		}
-		obj, err := Decode(c, exBytes)
-		if err != nil {
-			return fmt.Errorf("external type %s not interpretable: %v", et, err)
-		}
-		if reflect.TypeOf(obj) != reflect.TypeOf(internalType) {
-			return fmt.Errorf("decode of external type %s produced: %#v", et, obj)
-		}
-		if err = DecodeInto(c, exBytes, internalType); err != nil {
-			return fmt.Errorf("external type %s not convertible to internal type: %v", et, err)
-		}
-	}
-	return nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go b/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go
deleted file mode 100644
index d04d701f3..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/conversion.go
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
-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.
-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 runtime defines conversions between generic types and structs to map query strings
-// to struct objects.
-package runtime
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"k8s.io/apimachinery/pkg/conversion"
-)
-
-// DefaultMetaV1FieldSelectorConversion auto-accepts metav1 values for name and namespace.
-// A cluster scoped resource specifying namespace empty works fine and specifying a particular
-// namespace will return no results, as expected.
-func DefaultMetaV1FieldSelectorConversion(label, value string) (string, string, error) {
-	switch label {
-	case "metadata.name":
-		return label, value, nil
-	case "metadata.namespace":
-		return label, value, nil
-	default:
-		return "", "", fmt.Errorf("%q is not a known field selector: only %q, %q", label, "metadata.name", "metadata.namespace")
-	}
-}
-
-// JSONKeyMapper uses the struct tags on a conversion to determine the key value for
-// the other side. Use when mapping from a map[string]* to a struct or vice versa.
-func JSONKeyMapper(key string, sourceTag, destTag reflect.StructTag) (string, string) {
-	if s := destTag.Get("json"); len(s) > 0 {
-		return strings.SplitN(s, ",", 2)[0], key
-	}
-	if s := sourceTag.Get("json"); len(s) > 0 {
-		return key, strings.SplitN(s, ",", 2)[0]
-	}
-	return key, key
-}
-
-func Convert_Slice_string_To_string(in *[]string, out *string, s conversion.Scope) error {
-	if len(*in) == 0 {
-		*out = ""
-		return nil
-	}
-	*out = (*in)[0]
-	return nil
-}
-
-func Convert_Slice_string_To_int(in *[]string, out *int, s conversion.Scope) error {
-	if len(*in) == 0 {
-		*out = 0
-		return nil
-	}
-	str := (*in)[0]
-	i, err := strconv.Atoi(str)
-	if err != nil {
-		return err
-	}
-	*out = i
-	return nil
-}
-
-// Convert_Slice_string_To_bool will convert a string parameter to boolean.
-// Only the absence of a value (i.e. zero-length slice), a value of "false", or a
-// value of "0" resolve to false.
-// Any other value (including empty string) resolves to true.
-func Convert_Slice_string_To_bool(in *[]string, out *bool, s conversion.Scope) error {
-	if len(*in) == 0 {
-		*out = false
-		return nil
-	}
-	switch {
-	case (*in)[0] == "0", strings.EqualFold((*in)[0], "false"):
-		*out = false
-	default:
-		*out = true
-	}
-	return nil
-}
-
-// Convert_Slice_string_To_bool will convert a string parameter to boolean.
-// Only the absence of a value (i.e. zero-length slice), a value of "false", or a
-// value of "0" resolve to false.
-// Any other value (including empty string) resolves to true.
-func Convert_Slice_string_To_Pointer_bool(in *[]string, out **bool, s conversion.Scope) error {
-	if len(*in) == 0 {
-		boolVar := false
-		*out = &boolVar
-		return nil
-	}
-	switch {
-	case (*in)[0] == "0", strings.EqualFold((*in)[0], "false"):
-		boolVar := false
-		*out = &boolVar
-	default:
-		boolVar := true
-		*out = &boolVar
-	}
-	return nil
-}
-
-func string_to_int64(in string) (int64, error) {
-	return strconv.ParseInt(in, 10, 64)
-}
-
-func Convert_string_To_int64(in *string, out *int64, s conversion.Scope) error {
-	if in == nil {
-		*out = 0
-		return nil
-	}
-	i, err := string_to_int64(*in)
-	if err != nil {
-		return err
-	}
-	*out = i
-	return nil
-}
-
-func Convert_Slice_string_To_int64(in *[]string, out *int64, s conversion.Scope) error {
-	if len(*in) == 0 {
-		*out = 0
-		return nil
-	}
-	i, err := string_to_int64((*in)[0])
-	if err != nil {
-		return err
-	}
-	*out = i
-	return nil
-}
-
-func Convert_string_To_Pointer_int64(in *string, out **int64, s conversion.Scope) error {
-	if in == nil {
-		*out = nil
-		return nil
-	}
-	i, err := string_to_int64(*in)
-	if err != nil {
-		return err
-	}
-	*out = &i
-	return nil
-}
-
-func Convert_Slice_string_To_Pointer_int64(in *[]string, out **int64, s conversion.Scope) error {
-	if len(*in) == 0 {
-		*out = nil
-		return nil
-	}
-	i, err := string_to_int64((*in)[0])
-	if err != nil {
-		return err
-	}
-	*out = &i
-	return nil
-}
-
-func RegisterStringConversions(s *Scheme) error {
-	if err := s.AddConversionFunc((*[]string)(nil), (*string)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_Slice_string_To_string(a.(*[]string), b.(*string), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*[]string)(nil), (*int)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_Slice_string_To_int(a.(*[]string), b.(*int), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*[]string)(nil), (*bool)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_Slice_string_To_bool(a.(*[]string), b.(*bool), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*[]string)(nil), (*int64)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_Slice_string_To_int64(a.(*[]string), b.(*int64), scope)
-	}); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go b/vendor/k8s.io/apimachinery/pkg/runtime/converter.go
deleted file mode 100644
index 4a6cc6857..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/converter.go
+++ /dev/null
@@ -1,710 +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 runtime
-
-import (
-	encodingjson "encoding/json"
-	"fmt"
-	"math"
-	"os"
-	"reflect"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/apimachinery/pkg/util/json"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"sigs.k8s.io/structured-merge-diff/v4/value"
-
-	"k8s.io/klog/v2"
-)
-
-// UnstructuredConverter is an interface for converting between interface{}
-// and map[string]interface representation.
-type UnstructuredConverter interface {
-	ToUnstructured(obj interface{}) (map[string]interface{}, error)
-	FromUnstructured(u map[string]interface{}, obj interface{}) error
-}
-
-type structField struct {
-	structType reflect.Type
-	field      int
-}
-
-type fieldInfo struct {
-	name      string
-	nameValue reflect.Value
-	omitempty bool
-}
-
-type fieldsCacheMap map[structField]*fieldInfo
-
-type fieldsCache struct {
-	sync.Mutex
-	value atomic.Value
-}
-
-func newFieldsCache() *fieldsCache {
-	cache := &fieldsCache{}
-	cache.value.Store(make(fieldsCacheMap))
-	return cache
-}
-
-var (
-	mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
-	stringType             = reflect.TypeOf(string(""))
-	fieldCache             = newFieldsCache()
-
-	// DefaultUnstructuredConverter performs unstructured to Go typed object conversions.
-	DefaultUnstructuredConverter = &unstructuredConverter{
-		mismatchDetection: parseBool(os.Getenv("KUBE_PATCH_CONVERSION_DETECTOR")),
-		comparison: conversion.EqualitiesOrDie(
-			func(a, b time.Time) bool {
-				return a.UTC() == b.UTC()
-			},
-		),
-	}
-)
-
-func parseBool(key string) bool {
-	if len(key) == 0 {
-		return false
-	}
-	value, err := strconv.ParseBool(key)
-	if err != nil {
-		utilruntime.HandleError(fmt.Errorf("couldn't parse '%s' as bool for unstructured mismatch detection", key))
-	}
-	return value
-}
-
-// unstructuredConverter knows how to convert between interface{} and
-// Unstructured in both ways.
-type unstructuredConverter struct {
-	// If true, we will be additionally running conversion via json
-	// to ensure that the result is true.
-	// This is supposed to be set only in tests.
-	mismatchDetection bool
-	// comparison is the default test logic used to compare
-	comparison conversion.Equalities
-}
-
-// NewTestUnstructuredConverter creates an UnstructuredConverter that accepts JSON typed maps and translates them
-// to Go types via reflection. It performs mismatch detection automatically and is intended for use by external
-// test tools. Use DefaultUnstructuredConverter if you do not explicitly need mismatch detection.
-func NewTestUnstructuredConverter(comparison conversion.Equalities) UnstructuredConverter {
-	return &unstructuredConverter{
-		mismatchDetection: true,
-		comparison:        comparison,
-	}
-}
-
-// FromUnstructured converts an object from map[string]interface{} representation into a concrete type.
-// It uses encoding/json/Unmarshaler if object implements it or reflection if not.
-func (c *unstructuredConverter) FromUnstructured(u map[string]interface{}, obj interface{}) error {
-	t := reflect.TypeOf(obj)
-	value := reflect.ValueOf(obj)
-	if t.Kind() != reflect.Ptr || value.IsNil() {
-		return fmt.Errorf("FromUnstructured requires a non-nil pointer to an object, got %v", t)
-	}
-	err := fromUnstructured(reflect.ValueOf(u), value.Elem())
-	if c.mismatchDetection {
-		newObj := reflect.New(t.Elem()).Interface()
-		newErr := fromUnstructuredViaJSON(u, newObj)
-		if (err != nil) != (newErr != nil) {
-			klog.Fatalf("FromUnstructured unexpected error for %v: error: %v", u, err)
-		}
-		if err == nil && !c.comparison.DeepEqual(obj, newObj) {
-			klog.Fatalf("FromUnstructured mismatch\nobj1: %#v\nobj2: %#v", obj, newObj)
-		}
-	}
-	return err
-}
-
-func fromUnstructuredViaJSON(u map[string]interface{}, obj interface{}) error {
-	data, err := json.Marshal(u)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(data, obj)
-}
-
-func fromUnstructured(sv, dv reflect.Value) error {
-	sv = unwrapInterface(sv)
-	if !sv.IsValid() {
-		dv.Set(reflect.Zero(dv.Type()))
-		return nil
-	}
-	st, dt := sv.Type(), dv.Type()
-
-	switch dt.Kind() {
-	case reflect.Map, reflect.Slice, reflect.Ptr, reflect.Struct, reflect.Interface:
-		// Those require non-trivial conversion.
-	default:
-		// This should handle all simple types.
-		if st.AssignableTo(dt) {
-			dv.Set(sv)
-			return nil
-		}
-		// We cannot simply use "ConvertibleTo", as JSON doesn't support conversions
-		// between those four groups: bools, integers, floats and string. We need to
-		// do the same.
-		if st.ConvertibleTo(dt) {
-			switch st.Kind() {
-			case reflect.String:
-				switch dt.Kind() {
-				case reflect.String:
-					dv.Set(sv.Convert(dt))
-					return nil
-				}
-			case reflect.Bool:
-				switch dt.Kind() {
-				case reflect.Bool:
-					dv.Set(sv.Convert(dt))
-					return nil
-				}
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-				reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-				switch dt.Kind() {
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-					dv.Set(sv.Convert(dt))
-					return nil
-				case reflect.Float32, reflect.Float64:
-					dv.Set(sv.Convert(dt))
-					return nil
-				}
-			case reflect.Float32, reflect.Float64:
-				switch dt.Kind() {
-				case reflect.Float32, reflect.Float64:
-					dv.Set(sv.Convert(dt))
-					return nil
-				}
-				if sv.Float() == math.Trunc(sv.Float()) {
-					dv.Set(sv.Convert(dt))
-					return nil
-				}
-			}
-			return fmt.Errorf("cannot convert %s to %s", st.String(), dt.String())
-		}
-	}
-
-	// Check if the object has a custom JSON marshaller/unmarshaller.
-	entry := value.TypeReflectEntryOf(dv.Type())
-	if entry.CanConvertFromUnstructured() {
-		return entry.FromUnstructured(sv, dv)
-	}
-
-	switch dt.Kind() {
-	case reflect.Map:
-		return mapFromUnstructured(sv, dv)
-	case reflect.Slice:
-		return sliceFromUnstructured(sv, dv)
-	case reflect.Ptr:
-		return pointerFromUnstructured(sv, dv)
-	case reflect.Struct:
-		return structFromUnstructured(sv, dv)
-	case reflect.Interface:
-		return interfaceFromUnstructured(sv, dv)
-	default:
-		return fmt.Errorf("unrecognized type: %v", dt.Kind())
-	}
-}
-
-func fieldInfoFromField(structType reflect.Type, field int) *fieldInfo {
-	fieldCacheMap := fieldCache.value.Load().(fieldsCacheMap)
-	if info, ok := fieldCacheMap[structField{structType, field}]; ok {
-		return info
-	}
-
-	// Cache miss - we need to compute the field name.
-	info := &fieldInfo{}
-	typeField := structType.Field(field)
-	jsonTag := typeField.Tag.Get("json")
-	if len(jsonTag) == 0 {
-		// Make the first character lowercase.
-		if typeField.Name == "" {
-			info.name = typeField.Name
-		} else {
-			info.name = strings.ToLower(typeField.Name[:1]) + typeField.Name[1:]
-		}
-	} else {
-		items := strings.Split(jsonTag, ",")
-		info.name = items[0]
-		for i := range items {
-			if items[i] == "omitempty" {
-				info.omitempty = true
-				break
-			}
-		}
-	}
-	info.nameValue = reflect.ValueOf(info.name)
-
-	fieldCache.Lock()
-	defer fieldCache.Unlock()
-	fieldCacheMap = fieldCache.value.Load().(fieldsCacheMap)
-	newFieldCacheMap := make(fieldsCacheMap)
-	for k, v := range fieldCacheMap {
-		newFieldCacheMap[k] = v
-	}
-	newFieldCacheMap[structField{structType, field}] = info
-	fieldCache.value.Store(newFieldCacheMap)
-	return info
-}
-
-func unwrapInterface(v reflect.Value) reflect.Value {
-	for v.Kind() == reflect.Interface {
-		v = v.Elem()
-	}
-	return v
-}
-
-func mapFromUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if st.Kind() != reflect.Map {
-		return fmt.Errorf("cannot restore map from %v", st.Kind())
-	}
-
-	if !st.Key().AssignableTo(dt.Key()) && !st.Key().ConvertibleTo(dt.Key()) {
-		return fmt.Errorf("cannot copy map with non-assignable keys: %v %v", st.Key(), dt.Key())
-	}
-
-	if sv.IsNil() {
-		dv.Set(reflect.Zero(dt))
-		return nil
-	}
-	dv.Set(reflect.MakeMap(dt))
-	for _, key := range sv.MapKeys() {
-		value := reflect.New(dt.Elem()).Elem()
-		if val := unwrapInterface(sv.MapIndex(key)); val.IsValid() {
-			if err := fromUnstructured(val, value); err != nil {
-				return err
-			}
-		} else {
-			value.Set(reflect.Zero(dt.Elem()))
-		}
-		if st.Key().AssignableTo(dt.Key()) {
-			dv.SetMapIndex(key, value)
-		} else {
-			dv.SetMapIndex(key.Convert(dt.Key()), value)
-		}
-	}
-	return nil
-}
-
-func sliceFromUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if st.Kind() == reflect.String && dt.Elem().Kind() == reflect.Uint8 {
-		// We store original []byte representation as string.
-		// This conversion is allowed, but we need to be careful about
-		// marshaling data appropriately.
-		if len(sv.Interface().(string)) > 0 {
-			marshalled, err := json.Marshal(sv.Interface())
-			if err != nil {
-				return fmt.Errorf("error encoding %s to json: %v", st, err)
-			}
-			// TODO: Is this Unmarshal needed?
-			var data []byte
-			err = json.Unmarshal(marshalled, &data)
-			if err != nil {
-				return fmt.Errorf("error decoding from json: %v", err)
-			}
-			dv.SetBytes(data)
-		} else {
-			dv.Set(reflect.Zero(dt))
-		}
-		return nil
-	}
-	if st.Kind() != reflect.Slice {
-		return fmt.Errorf("cannot restore slice from %v", st.Kind())
-	}
-
-	if sv.IsNil() {
-		dv.Set(reflect.Zero(dt))
-		return nil
-	}
-	dv.Set(reflect.MakeSlice(dt, sv.Len(), sv.Cap()))
-	for i := 0; i < sv.Len(); i++ {
-		if err := fromUnstructured(sv.Index(i), dv.Index(i)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func pointerFromUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-
-	if st.Kind() == reflect.Ptr && sv.IsNil() {
-		dv.Set(reflect.Zero(dt))
-		return nil
-	}
-	dv.Set(reflect.New(dt.Elem()))
-	switch st.Kind() {
-	case reflect.Ptr, reflect.Interface:
-		return fromUnstructured(sv.Elem(), dv.Elem())
-	default:
-		return fromUnstructured(sv, dv.Elem())
-	}
-}
-
-func structFromUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if st.Kind() != reflect.Map {
-		return fmt.Errorf("cannot restore struct from: %v", st.Kind())
-	}
-
-	for i := 0; i < dt.NumField(); i++ {
-		fieldInfo := fieldInfoFromField(dt, i)
-		fv := dv.Field(i)
-
-		if len(fieldInfo.name) == 0 {
-			// This field is inlined.
-			if err := fromUnstructured(sv, fv); err != nil {
-				return err
-			}
-		} else {
-			value := unwrapInterface(sv.MapIndex(fieldInfo.nameValue))
-			if value.IsValid() {
-				if err := fromUnstructured(value, fv); err != nil {
-					return err
-				}
-			} else {
-				fv.Set(reflect.Zero(fv.Type()))
-			}
-		}
-	}
-	return nil
-}
-
-func interfaceFromUnstructured(sv, dv reflect.Value) error {
-	// TODO: Is this conversion safe?
-	dv.Set(sv)
-	return nil
-}
-
-// ToUnstructured converts an object into map[string]interface{} representation.
-// It uses encoding/json/Marshaler if object implements it or reflection if not.
-func (c *unstructuredConverter) ToUnstructured(obj interface{}) (map[string]interface{}, error) {
-	var u map[string]interface{}
-	var err error
-	if unstr, ok := obj.(Unstructured); ok {
-		u = unstr.UnstructuredContent()
-	} else {
-		t := reflect.TypeOf(obj)
-		value := reflect.ValueOf(obj)
-		if t.Kind() != reflect.Ptr || value.IsNil() {
-			return nil, fmt.Errorf("ToUnstructured requires a non-nil pointer to an object, got %v", t)
-		}
-		u = map[string]interface{}{}
-		err = toUnstructured(value.Elem(), reflect.ValueOf(&u).Elem())
-	}
-	if c.mismatchDetection {
-		newUnstr := map[string]interface{}{}
-		newErr := toUnstructuredViaJSON(obj, &newUnstr)
-		if (err != nil) != (newErr != nil) {
-			klog.Fatalf("ToUnstructured unexpected error for %v: error: %v; newErr: %v", obj, err, newErr)
-		}
-		if err == nil && !c.comparison.DeepEqual(u, newUnstr) {
-			klog.Fatalf("ToUnstructured mismatch\nobj1: %#v\nobj2: %#v", u, newUnstr)
-		}
-	}
-	if err != nil {
-		return nil, err
-	}
-	return u, nil
-}
-
-// DeepCopyJSON deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
-// types produced by json.Unmarshal() and also int64.
-// bool, int64, float64, string, []interface{}, map[string]interface{}, json.Number and nil
-func DeepCopyJSON(x map[string]interface{}) map[string]interface{} {
-	return DeepCopyJSONValue(x).(map[string]interface{})
-}
-
-// DeepCopyJSONValue deep copies the passed value, assuming it is a valid JSON representation i.e. only contains
-// types produced by json.Unmarshal() and also int64.
-// bool, int64, float64, string, []interface{}, map[string]interface{}, json.Number and nil
-func DeepCopyJSONValue(x interface{}) interface{} {
-	switch x := x.(type) {
-	case map[string]interface{}:
-		if x == nil {
-			// Typed nil - an interface{} that contains a type map[string]interface{} with a value of nil
-			return x
-		}
-		clone := make(map[string]interface{}, len(x))
-		for k, v := range x {
-			clone[k] = DeepCopyJSONValue(v)
-		}
-		return clone
-	case []interface{}:
-		if x == nil {
-			// Typed nil - an interface{} that contains a type []interface{} with a value of nil
-			return x
-		}
-		clone := make([]interface{}, len(x))
-		for i, v := range x {
-			clone[i] = DeepCopyJSONValue(v)
-		}
-		return clone
-	case string, int64, bool, float64, nil, encodingjson.Number:
-		return x
-	default:
-		panic(fmt.Errorf("cannot deep copy %T", x))
-	}
-}
-
-func toUnstructuredViaJSON(obj interface{}, u *map[string]interface{}) error {
-	data, err := json.Marshal(obj)
-	if err != nil {
-		return err
-	}
-	return json.Unmarshal(data, u)
-}
-
-func toUnstructured(sv, dv reflect.Value) error {
-	// Check if the object has a custom string converter.
-	entry := value.TypeReflectEntryOf(sv.Type())
-	if entry.CanConvertToUnstructured() {
-		v, err := entry.ToUnstructured(sv)
-		if err != nil {
-			return err
-		}
-		if v != nil {
-			dv.Set(reflect.ValueOf(v))
-		}
-		return nil
-	}
-	st := sv.Type()
-	switch st.Kind() {
-	case reflect.String:
-		dv.Set(reflect.ValueOf(sv.String()))
-		return nil
-	case reflect.Bool:
-		dv.Set(reflect.ValueOf(sv.Bool()))
-		return nil
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		dv.Set(reflect.ValueOf(sv.Int()))
-		return nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		uVal := sv.Uint()
-		if uVal > math.MaxInt64 {
-			return fmt.Errorf("unsigned value %d does not fit into int64 (overflow)", uVal)
-		}
-		dv.Set(reflect.ValueOf(int64(uVal)))
-		return nil
-	case reflect.Float32, reflect.Float64:
-		dv.Set(reflect.ValueOf(sv.Float()))
-		return nil
-	case reflect.Map:
-		return mapToUnstructured(sv, dv)
-	case reflect.Slice:
-		return sliceToUnstructured(sv, dv)
-	case reflect.Ptr:
-		return pointerToUnstructured(sv, dv)
-	case reflect.Struct:
-		return structToUnstructured(sv, dv)
-	case reflect.Interface:
-		return interfaceToUnstructured(sv, dv)
-	default:
-		return fmt.Errorf("unrecognized type: %v", st.Kind())
-	}
-}
-
-func mapToUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if sv.IsNil() {
-		dv.Set(reflect.Zero(dt))
-		return nil
-	}
-	if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 {
-		if st.Key().Kind() == reflect.String {
-			switch st.Elem().Kind() {
-			// TODO It should be possible to reuse the slice for primitive types.
-			// However, it is panicing in the following form.
-			// case reflect.String, reflect.Bool,
-			// 	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-			// 	reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			// 	sv.Set(sv)
-			// 	return nil
-			default:
-				// We need to do a proper conversion.
-			}
-		}
-		dv.Set(reflect.MakeMap(mapStringInterfaceType))
-		dv = dv.Elem()
-		dt = dv.Type()
-	}
-	if dt.Kind() != reflect.Map {
-		return fmt.Errorf("cannot convert struct to: %v", dt.Kind())
-	}
-
-	if !st.Key().AssignableTo(dt.Key()) && !st.Key().ConvertibleTo(dt.Key()) {
-		return fmt.Errorf("cannot copy map with non-assignable keys: %v %v", st.Key(), dt.Key())
-	}
-
-	for _, key := range sv.MapKeys() {
-		value := reflect.New(dt.Elem()).Elem()
-		if err := toUnstructured(sv.MapIndex(key), value); err != nil {
-			return err
-		}
-		if st.Key().AssignableTo(dt.Key()) {
-			dv.SetMapIndex(key, value)
-		} else {
-			dv.SetMapIndex(key.Convert(dt.Key()), value)
-		}
-	}
-	return nil
-}
-
-func sliceToUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if sv.IsNil() {
-		dv.Set(reflect.Zero(dt))
-		return nil
-	}
-	if st.Elem().Kind() == reflect.Uint8 {
-		dv.Set(reflect.New(stringType))
-		data, err := json.Marshal(sv.Bytes())
-		if err != nil {
-			return err
-		}
-		var result string
-		if err = json.Unmarshal(data, &result); err != nil {
-			return err
-		}
-		dv.Set(reflect.ValueOf(result))
-		return nil
-	}
-	if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 {
-		switch st.Elem().Kind() {
-		// TODO It should be possible to reuse the slice for primitive types.
-		// However, it is panicing in the following form.
-		// case reflect.String, reflect.Bool,
-		// 	reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		// 	reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		// 	sv.Set(sv)
-		// 	return nil
-		default:
-			// We need to do a proper conversion.
-			dv.Set(reflect.MakeSlice(reflect.SliceOf(dt), sv.Len(), sv.Cap()))
-			dv = dv.Elem()
-			dt = dv.Type()
-		}
-	}
-	if dt.Kind() != reflect.Slice {
-		return fmt.Errorf("cannot convert slice to: %v", dt.Kind())
-	}
-	for i := 0; i < sv.Len(); i++ {
-		if err := toUnstructured(sv.Index(i), dv.Index(i)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func pointerToUnstructured(sv, dv reflect.Value) error {
-	if sv.IsNil() {
-		// We're done - we don't need to store anything.
-		return nil
-	}
-	return toUnstructured(sv.Elem(), dv)
-}
-
-func isZero(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Array, reflect.String:
-		return v.Len() == 0
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.Map, reflect.Slice:
-		// TODO: It seems that 0-len maps are ignored in it.
-		return v.IsNil() || v.Len() == 0
-	case reflect.Ptr, reflect.Interface:
-		return v.IsNil()
-	}
-	return false
-}
-
-func structToUnstructured(sv, dv reflect.Value) error {
-	st, dt := sv.Type(), dv.Type()
-	if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 {
-		dv.Set(reflect.MakeMapWithSize(mapStringInterfaceType, st.NumField()))
-		dv = dv.Elem()
-		dt = dv.Type()
-	}
-	if dt.Kind() != reflect.Map {
-		return fmt.Errorf("cannot convert struct to: %v", dt.Kind())
-	}
-	realMap := dv.Interface().(map[string]interface{})
-
-	for i := 0; i < st.NumField(); i++ {
-		fieldInfo := fieldInfoFromField(st, i)
-		fv := sv.Field(i)
-
-		if fieldInfo.name == "-" {
-			// This field should be skipped.
-			continue
-		}
-		if fieldInfo.omitempty && isZero(fv) {
-			// omitempty fields should be ignored.
-			continue
-		}
-		if len(fieldInfo.name) == 0 {
-			// This field is inlined.
-			if err := toUnstructured(fv, dv); err != nil {
-				return err
-			}
-			continue
-		}
-		switch fv.Type().Kind() {
-		case reflect.String:
-			realMap[fieldInfo.name] = fv.String()
-		case reflect.Bool:
-			realMap[fieldInfo.name] = fv.Bool()
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			realMap[fieldInfo.name] = fv.Int()
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			realMap[fieldInfo.name] = fv.Uint()
-		case reflect.Float32, reflect.Float64:
-			realMap[fieldInfo.name] = fv.Float()
-		default:
-			subv := reflect.New(dt.Elem()).Elem()
-			if err := toUnstructured(fv, subv); err != nil {
-				return err
-			}
-			dv.SetMapIndex(fieldInfo.nameValue, subv)
-		}
-	}
-	return nil
-}
-
-func interfaceToUnstructured(sv, dv reflect.Value) error {
-	if !sv.IsValid() || sv.IsNil() {
-		dv.Set(reflect.Zero(dv.Type()))
-		return nil
-	}
-	return toUnstructured(sv.Elem(), dv)
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/doc.go b/vendor/k8s.io/apimachinery/pkg/runtime/doc.go
deleted file mode 100644
index 89feb4010..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/doc.go
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-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.
-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 runtime includes helper functions for working with API objects
-// that follow the kubernetes API object conventions, which are:
-//
-// 0. Your API objects have a common metadata struct member, TypeMeta.
-//
-// 1. Your code refers to an internal set of API objects.
-//
-// 2. In a separate package, you have an external set of API objects.
-//
-// 3. The external set is considered to be versioned, and no breaking
-// changes are ever made to it (fields may be added but not changed
-// or removed).
-//
-// 4. As your api evolves, you'll make an additional versioned package
-// with every major change.
-//
-// 5. Versioned packages have conversion functions which convert to
-// and from the internal version.
-//
-// 6. You'll continue to support older versions according to your
-// deprecation policy, and you can easily provide a program/library
-// to update old versions into new versions because of 5.
-//
-// 7. All of your serializations and deserializations are handled in a
-// centralized place.
-//
-// Package runtime provides a conversion helper to make 5 easy, and the
-// Encode/Decode/DecodeInto trio to accomplish 7. You can also register
-// additional "codecs" which use a version of your choice. It's
-// recommended that you register your types with runtime in your
-// package's init function.
-//
-// As a bonus, a few common types useful from all api objects and versions
-// are provided in types.go.
-package runtime // import "k8s.io/apimachinery/pkg/runtime"
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go b/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go
deleted file mode 100644
index 7251e65f6..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/embedded.go
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"errors"
-
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-type encodable struct {
-	E        Encoder `json:"-"`
-	obj      Object
-	versions []schema.GroupVersion
-}
-
-func (e encodable) GetObjectKind() schema.ObjectKind { return e.obj.GetObjectKind() }
-func (e encodable) DeepCopyObject() Object {
-	out := e
-	out.obj = e.obj.DeepCopyObject()
-	copy(out.versions, e.versions)
-	return out
-}
-
-// NewEncodable creates an object that will be encoded with the provided codec on demand.
-// Provided as a convenience for test cases dealing with internal objects.
-func NewEncodable(e Encoder, obj Object, versions ...schema.GroupVersion) Object {
-	if _, ok := obj.(*Unknown); ok {
-		return obj
-	}
-	return encodable{e, obj, versions}
-}
-
-func (e encodable) UnmarshalJSON(in []byte) error {
-	return errors.New("runtime.encodable cannot be unmarshalled from JSON")
-}
-
-// Marshal may get called on pointers or values, so implement MarshalJSON on value.
-// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
-func (e encodable) MarshalJSON() ([]byte, error) {
-	return Encode(e.E, e.obj)
-}
-
-// NewEncodableList creates an object that will be encoded with the provided codec on demand.
-// Provided as a convenience for test cases dealing with internal objects.
-func NewEncodableList(e Encoder, objects []Object, versions ...schema.GroupVersion) []Object {
-	out := make([]Object, len(objects))
-	for i := range objects {
-		if _, ok := objects[i].(*Unknown); ok {
-			out[i] = objects[i]
-			continue
-		}
-		out[i] = NewEncodable(e, objects[i], versions...)
-	}
-	return out
-}
-
-func (e *Unknown) UnmarshalJSON(in []byte) error {
-	if e == nil {
-		return errors.New("runtime.Unknown: UnmarshalJSON on nil pointer")
-	}
-	e.TypeMeta = TypeMeta{}
-	e.Raw = append(e.Raw[0:0], in...)
-	e.ContentEncoding = ""
-	e.ContentType = ContentTypeJSON
-	return nil
-}
-
-// Marshal may get called on pointers or values, so implement MarshalJSON on value.
-// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
-func (e Unknown) MarshalJSON() ([]byte, error) {
-	// If ContentType is unset, we assume this is JSON.
-	if e.ContentType != "" && e.ContentType != ContentTypeJSON {
-		return nil, errors.New("runtime.Unknown: MarshalJSON on non-json data")
-	}
-	if e.Raw == nil {
-		return []byte("null"), nil
-	}
-	return e.Raw, nil
-}
-
-func Convert_runtime_Object_To_runtime_RawExtension(in *Object, out *RawExtension, s conversion.Scope) error {
-	if in == nil {
-		out.Raw = []byte("null")
-		return nil
-	}
-	obj := *in
-	if unk, ok := obj.(*Unknown); ok {
-		if unk.Raw != nil {
-			out.Raw = unk.Raw
-			return nil
-		}
-		obj = out.Object
-	}
-	if obj == nil {
-		out.Raw = nil
-		return nil
-	}
-	out.Object = obj
-	return nil
-}
-
-func Convert_runtime_RawExtension_To_runtime_Object(in *RawExtension, out *Object, s conversion.Scope) error {
-	if in.Object != nil {
-		*out = in.Object
-		return nil
-	}
-	data := in.Raw
-	if len(data) == 0 || (len(data) == 4 && string(data) == "null") {
-		*out = nil
-		return nil
-	}
-	*out = &Unknown{
-		Raw: data,
-		// TODO: Set ContentEncoding and ContentType appropriately.
-		// Currently we set ContentTypeJSON to make tests passing.
-		ContentType: ContentTypeJSON,
-	}
-	return nil
-}
-
-func RegisterEmbeddedConversions(s *Scheme) error {
-	if err := s.AddConversionFunc((*Object)(nil), (*RawExtension)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_runtime_Object_To_runtime_RawExtension(a.(*Object), b.(*RawExtension), scope)
-	}); err != nil {
-		return err
-	}
-	if err := s.AddConversionFunc((*RawExtension)(nil), (*Object)(nil), func(a, b interface{}, scope conversion.Scope) error {
-		return Convert_runtime_RawExtension_To_runtime_Object(a.(*RawExtension), b.(*Object), scope)
-	}); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/error.go b/vendor/k8s.io/apimachinery/pkg/runtime/error.go
deleted file mode 100644
index be0c5edc8..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/error.go
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"fmt"
-	"reflect"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-type notRegisteredErr struct {
-	schemeName string
-	gvk        schema.GroupVersionKind
-	target     GroupVersioner
-	t          reflect.Type
-}
-
-func NewNotRegisteredErrForKind(schemeName string, gvk schema.GroupVersionKind) error {
-	return &notRegisteredErr{schemeName: schemeName, gvk: gvk}
-}
-
-func NewNotRegisteredErrForType(schemeName string, t reflect.Type) error {
-	return &notRegisteredErr{schemeName: schemeName, t: t}
-}
-
-func NewNotRegisteredErrForTarget(schemeName string, t reflect.Type, target GroupVersioner) error {
-	return &notRegisteredErr{schemeName: schemeName, t: t, target: target}
-}
-
-func NewNotRegisteredGVKErrForTarget(schemeName string, gvk schema.GroupVersionKind, target GroupVersioner) error {
-	return &notRegisteredErr{schemeName: schemeName, gvk: gvk, target: target}
-}
-
-func (k *notRegisteredErr) Error() string {
-	if k.t != nil && k.target != nil {
-		return fmt.Sprintf("%v is not suitable for converting to %q in scheme %q", k.t, k.target, k.schemeName)
-	}
-	nullGVK := schema.GroupVersionKind{}
-	if k.gvk != nullGVK && k.target != nil {
-		return fmt.Sprintf("%q is not suitable for converting to %q in scheme %q", k.gvk.GroupVersion(), k.target, k.schemeName)
-	}
-	if k.t != nil {
-		return fmt.Sprintf("no kind is registered for the type %v in scheme %q", k.t, k.schemeName)
-	}
-	if len(k.gvk.Kind) == 0 {
-		return fmt.Sprintf("no version %q has been registered in scheme %q", k.gvk.GroupVersion(), k.schemeName)
-	}
-	if k.gvk.Version == APIVersionInternal {
-		return fmt.Sprintf("no kind %q is registered for the internal version of group %q in scheme %q", k.gvk.Kind, k.gvk.Group, k.schemeName)
-	}
-
-	return fmt.Sprintf("no kind %q is registered for version %q in scheme %q", k.gvk.Kind, k.gvk.GroupVersion(), k.schemeName)
-}
-
-// IsNotRegisteredError returns true if the error indicates the provided
-// object or input data is not registered.
-func IsNotRegisteredError(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(*notRegisteredErr)
-	return ok
-}
-
-type missingKindErr struct {
-	data string
-}
-
-func NewMissingKindErr(data string) error {
-	return &missingKindErr{data}
-}
-
-func (k *missingKindErr) Error() string {
-	return fmt.Sprintf("Object 'Kind' is missing in '%s'", k.data)
-}
-
-// IsMissingKind returns true if the error indicates that the provided object
-// is missing a 'Kind' field.
-func IsMissingKind(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(*missingKindErr)
-	return ok
-}
-
-type missingVersionErr struct {
-	data string
-}
-
-func NewMissingVersionErr(data string) error {
-	return &missingVersionErr{data}
-}
-
-func (k *missingVersionErr) Error() string {
-	return fmt.Sprintf("Object 'apiVersion' is missing in '%s'", k.data)
-}
-
-// IsMissingVersion returns true if the error indicates that the provided object
-// is missing a 'Version' field.
-func IsMissingVersion(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(*missingVersionErr)
-	return ok
-}
-
-// strictDecodingError is a base error type that is returned by a strict Decoder such
-// as UniversalStrictDecoder.
-type strictDecodingError struct {
-	message string
-	data    string
-}
-
-// NewStrictDecodingError creates a new strictDecodingError object.
-func NewStrictDecodingError(message string, data string) error {
-	return &strictDecodingError{
-		message: message,
-		data:    data,
-	}
-}
-
-func (e *strictDecodingError) Error() string {
-	return fmt.Sprintf("strict decoder error for %s: %s", e.data, e.message)
-}
-
-// IsStrictDecodingError returns true if the error indicates that the provided object
-// strictness violations.
-func IsStrictDecodingError(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(*strictDecodingError)
-	return ok
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/extension.go b/vendor/k8s.io/apimachinery/pkg/runtime/extension.go
deleted file mode 100644
index 9056397fa..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/extension.go
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-)
-
-func (re *RawExtension) UnmarshalJSON(in []byte) error {
-	if re == nil {
-		return errors.New("runtime.RawExtension: UnmarshalJSON on nil pointer")
-	}
-	if !bytes.Equal(in, []byte("null")) {
-		re.Raw = append(re.Raw[0:0], in...)
-	}
-	return nil
-}
-
-// MarshalJSON may get called on pointers or values, so implement MarshalJSON on value.
-// http://stackoverflow.com/questions/21390979/custom-marshaljson-never-gets-called-in-go
-func (re RawExtension) MarshalJSON() ([]byte, error) {
-	if re.Raw == nil {
-		// TODO: this is to support legacy behavior of JSONPrinter and YAMLPrinter, which
-		// expect to call json.Marshal on arbitrary versioned objects (even those not in
-		// the scheme). pkg/kubectl/resource#AsVersionedObjects and its interaction with
-		// kubectl get on objects not in the scheme needs to be updated to ensure that the
-		// objects that are not part of the scheme are correctly put into the right form.
-		if re.Object != nil {
-			return json.Marshal(re.Object)
-		}
-		return []byte("null"), nil
-	}
-	// TODO: Check whether ContentType is actually JSON before returning it.
-	return re.Raw, nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go
deleted file mode 100644
index ac428d610..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/generated.pb.go
+++ /dev/null
@@ -1,846 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
-
-package runtime
-
-import (
-	fmt "fmt"
-
-	io "io"
-	math "math"
-	math_bits "math/bits"
-	reflect "reflect"
-	strings "strings"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-func (m *RawExtension) Reset()      { *m = RawExtension{} }
-func (*RawExtension) ProtoMessage() {}
-func (*RawExtension) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9d3c45d7f546725c, []int{0}
-}
-func (m *RawExtension) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *RawExtension) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	b = b[:cap(b)]
-	n, err := m.MarshalToSizedBuffer(b)
-	if err != nil {
-		return nil, err
-	}
-	return b[:n], nil
-}
-func (m *RawExtension) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RawExtension.Merge(m, src)
-}
-func (m *RawExtension) XXX_Size() int {
-	return m.Size()
-}
-func (m *RawExtension) XXX_DiscardUnknown() {
-	xxx_messageInfo_RawExtension.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RawExtension proto.InternalMessageInfo
-
-func (m *TypeMeta) Reset()      { *m = TypeMeta{} }
-func (*TypeMeta) ProtoMessage() {}
-func (*TypeMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9d3c45d7f546725c, []int{1}
-}
-func (m *TypeMeta) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *TypeMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	b = b[:cap(b)]
-	n, err := m.MarshalToSizedBuffer(b)
-	if err != nil {
-		return nil, err
-	}
-	return b[:n], nil
-}
-func (m *TypeMeta) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TypeMeta.Merge(m, src)
-}
-func (m *TypeMeta) XXX_Size() int {
-	return m.Size()
-}
-func (m *TypeMeta) XXX_DiscardUnknown() {
-	xxx_messageInfo_TypeMeta.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TypeMeta proto.InternalMessageInfo
-
-func (m *Unknown) Reset()      { *m = Unknown{} }
-func (*Unknown) ProtoMessage() {}
-func (*Unknown) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9d3c45d7f546725c, []int{2}
-}
-func (m *Unknown) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Unknown) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	b = b[:cap(b)]
-	n, err := m.MarshalToSizedBuffer(b)
-	if err != nil {
-		return nil, err
-	}
-	return b[:n], nil
-}
-func (m *Unknown) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Unknown.Merge(m, src)
-}
-func (m *Unknown) XXX_Size() int {
-	return m.Size()
-}
-func (m *Unknown) XXX_DiscardUnknown() {
-	xxx_messageInfo_Unknown.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Unknown proto.InternalMessageInfo
-
-func init() {
-	proto.RegisterType((*RawExtension)(nil), "k8s.io.apimachinery.pkg.runtime.RawExtension")
-	proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.runtime.TypeMeta")
-	proto.RegisterType((*Unknown)(nil), "k8s.io.apimachinery.pkg.runtime.Unknown")
-}
-
-func init() {
-	proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto", fileDescriptor_9d3c45d7f546725c)
-}
-
-var fileDescriptor_9d3c45d7f546725c = []byte{
-	// 378 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x4f, 0xab, 0x13, 0x31,
-	0x14, 0xc5, 0x27, 0xaf, 0x85, 0x3e, 0xd3, 0xc2, 0x93, 0xb8, 0x70, 0x74, 0x91, 0x79, 0x74, 0xe5,
-	0x5b, 0xbc, 0x04, 0x1e, 0x08, 0x6e, 0x3b, 0xa5, 0xa0, 0x88, 0x20, 0xc1, 0x3f, 0xe0, 0xca, 0x74,
-	0x26, 0x4e, 0xc3, 0xd0, 0x9b, 0x21, 0xcd, 0x38, 0x76, 0xe7, 0x47, 0xf0, 0x63, 0x75, 0xd9, 0x65,
-	0x57, 0xc5, 0x8e, 0x1f, 0xc2, 0xad, 0x34, 0x4d, 0x6b, 0xd5, 0x85, 0xbb, 0xe4, 0x9e, 0xf3, 0x3b,
-	0xf7, 0x1e, 0xfc, 0xbc, 0x7c, 0xb6, 0x60, 0xda, 0xf0, 0xb2, 0x9e, 0x2a, 0x0b, 0xca, 0xa9, 0x05,
-	0xff, 0xac, 0x20, 0x37, 0x96, 0x07, 0x41, 0x56, 0x7a, 0x2e, 0xb3, 0x99, 0x06, 0x65, 0x97, 0xbc,
-	0x2a, 0x0b, 0x6e, 0x6b, 0x70, 0x7a, 0xae, 0x78, 0xa1, 0x40, 0x59, 0xe9, 0x54, 0xce, 0x2a, 0x6b,
-	0x9c, 0x21, 0xc9, 0x01, 0x60, 0xe7, 0x00, 0xab, 0xca, 0x82, 0x05, 0xe0, 0xf1, 0x6d, 0xa1, 0xdd,
-	0xac, 0x9e, 0xb2, 0xcc, 0xcc, 0x79, 0x61, 0x0a, 0xc3, 0x3d, 0x37, 0xad, 0x3f, 0xf9, 0x9f, 0xff,
-	0xf8, 0xd7, 0x21, 0x6f, 0x78, 0x83, 0x07, 0x42, 0x36, 0x93, 0x2f, 0x4e, 0xc1, 0x42, 0x1b, 0x20,
-	0x8f, 0x70, 0xc7, 0xca, 0x26, 0x46, 0xd7, 0xe8, 0xc9, 0x20, 0xed, 0xb5, 0xdb, 0xa4, 0x23, 0x64,
-	0x23, 0xf6, 0xb3, 0xe1, 0x47, 0x7c, 0xf9, 0x66, 0x59, 0xa9, 0x57, 0xca, 0x49, 0x72, 0x87, 0xb1,
-	0xac, 0xf4, 0x3b, 0x65, 0xf7, 0x90, 0x77, 0xdf, 0x4b, 0xc9, 0x6a, 0x9b, 0x44, 0xed, 0x36, 0xc1,
-	0xa3, 0xd7, 0x2f, 0x82, 0x22, 0xce, 0x5c, 0xe4, 0x1a, 0x77, 0x4b, 0x0d, 0x79, 0x7c, 0xe1, 0xdd,
-	0x83, 0xe0, 0xee, 0xbe, 0xd4, 0x90, 0x0b, 0xaf, 0x0c, 0x7f, 0x22, 0xdc, 0x7b, 0x0b, 0x25, 0x98,
-	0x06, 0xc8, 0x7b, 0x7c, 0xe9, 0xc2, 0x36, 0x9f, 0xdf, 0xbf, 0xbb, 0x61, 0xff, 0xe9, 0xce, 0x8e,
-	0xe7, 0xa5, 0xf7, 0x43, 0xf8, 0xe9, 0x60, 0x71, 0x0a, 0x3b, 0x36, 0xbc, 0xf8, 0xb7, 0x21, 0x19,
-	0xe1, 0xab, 0xcc, 0x80, 0x53, 0xe0, 0x26, 0x90, 0x99, 0x5c, 0x43, 0x11, 0x77, 0xfc, 0xb1, 0x0f,
-	0x43, 0xde, 0xd5, 0xf8, 0x4f, 0x59, 0xfc, 0xed, 0x27, 0x4f, 0x71, 0x3f, 0x8c, 0xf6, 0xab, 0xe3,
-	0xae, 0xc7, 0x1f, 0x04, 0xbc, 0x3f, 0xfe, 0x2d, 0x89, 0x73, 0x5f, 0x7a, 0xbb, 0xda, 0xd1, 0x68,
-	0xbd, 0xa3, 0xd1, 0x66, 0x47, 0xa3, 0xaf, 0x2d, 0x45, 0xab, 0x96, 0xa2, 0x75, 0x4b, 0xd1, 0xa6,
-	0xa5, 0xe8, 0x7b, 0x4b, 0xd1, 0xb7, 0x1f, 0x34, 0xfa, 0xd0, 0x0b, 0x45, 0x7f, 0x05, 0x00, 0x00,
-	0xff, 0xff, 0xe3, 0x33, 0x18, 0x0b, 0x50, 0x02, 0x00, 0x00,
-}
-
-func (m *RawExtension) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *RawExtension) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RawExtension) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Raw != nil {
-		i -= len(m.Raw)
-		copy(dAtA[i:], m.Raw)
-		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *TypeMeta) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TypeMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i -= len(m.Kind)
-	copy(dAtA[i:], m.Kind)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
-	i--
-	dAtA[i] = 0x12
-	i -= len(m.APIVersion)
-	copy(dAtA[i:], m.APIVersion)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func (m *Unknown) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *Unknown) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Unknown) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	i -= len(m.ContentType)
-	copy(dAtA[i:], m.ContentType)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentType)))
-	i--
-	dAtA[i] = 0x22
-	i -= len(m.ContentEncoding)
-	copy(dAtA[i:], m.ContentEncoding)
-	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentEncoding)))
-	i--
-	dAtA[i] = 0x1a
-	if m.Raw != nil {
-		i -= len(m.Raw)
-		copy(dAtA[i:], m.Raw)
-		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
-		i--
-		dAtA[i] = 0x12
-	}
-	{
-		size, err := m.TypeMeta.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintGenerated(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
-	offset -= sovGenerated(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *RawExtension) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Raw != nil {
-		l = len(m.Raw)
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	return n
-}
-
-func (m *TypeMeta) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.APIVersion)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.Kind)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func (m *Unknown) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = m.TypeMeta.Size()
-	n += 1 + l + sovGenerated(uint64(l))
-	if m.Raw != nil {
-		l = len(m.Raw)
-		n += 1 + l + sovGenerated(uint64(l))
-	}
-	l = len(m.ContentEncoding)
-	n += 1 + l + sovGenerated(uint64(l))
-	l = len(m.ContentType)
-	n += 1 + l + sovGenerated(uint64(l))
-	return n
-}
-
-func sovGenerated(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozGenerated(x uint64) (n int) {
-	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (this *RawExtension) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&RawExtension{`,
-		`Raw:` + valueToStringGenerated(this.Raw) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *TypeMeta) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&TypeMeta{`,
-		`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
-		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *Unknown) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&Unknown{`,
-		`TypeMeta:` + strings.Replace(strings.Replace(this.TypeMeta.String(), "TypeMeta", "TypeMeta", 1), `&`, ``, 1) + `,`,
-		`Raw:` + valueToStringGenerated(this.Raw) + `,`,
-		`ContentEncoding:` + fmt.Sprintf("%v", this.ContentEncoding) + `,`,
-		`ContentType:` + fmt.Sprintf("%v", this.ContentType) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func valueToStringGenerated(v interface{}) string {
-	rv := reflect.ValueOf(v)
-	if rv.IsNil() {
-		return "nil"
-	}
-	pv := reflect.Indirect(rv).Interface()
-	return fmt.Sprintf("*%v", pv)
-}
-func (m *RawExtension) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenerated
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RawExtension: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RawExtension: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
-			if m.Raw == nil {
-				m.Raw = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *TypeMeta) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenerated
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.APIVersion = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Kind = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *Unknown) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowGenerated
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: Unknown: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Unknown: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field TypeMeta", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.TypeMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
-			if m.Raw == nil {
-				m.Raw = []byte{}
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContentEncoding", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ContentEncoding = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.ContentType = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipGenerated(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthGenerated
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipGenerated(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowGenerated
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowGenerated
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthGenerated
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupGenerated
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthGenerated
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
-)
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto b/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
deleted file mode 100644
index 3b25391fa..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-
-// This file was autogenerated by go-to-protobuf. Do not edit it manually!
-
-syntax = "proto2";
-
-package k8s.io.apimachinery.pkg.runtime;
-
-// Package-wide variables from generator "generated".
-option go_package = "runtime";
-
-// RawExtension is used to hold extensions in external versions.
-//
-// To use this, make a field which has RawExtension as its type in your external, versioned
-// struct, and Object in your internal struct. You also need to register your
-// various plugin types.
-//
-// // Internal package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-// 	MyPlugin runtime.Object `json:"myPlugin"`
-// }
-// type PluginA struct {
-// 	AOption string `json:"aOption"`
-// }
-//
-// // External package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-// 	MyPlugin runtime.RawExtension `json:"myPlugin"`
-// }
-// type PluginA struct {
-// 	AOption string `json:"aOption"`
-// }
-//
-// // On the wire, the JSON will look something like this:
-// {
-// 	"kind":"MyAPIObject",
-// 	"apiVersion":"v1",
-// 	"myPlugin": {
-// 		"kind":"PluginA",
-// 		"aOption":"foo",
-// 	},
-// }
-//
-// So what happens? Decode first uses json or yaml to unmarshal the serialized data into
-// your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked.
-// The next step is to copy (using pkg/conversion) into the internal struct. The runtime
-// package's DefaultScheme has conversion functions installed which will unpack the
-// JSON stored in RawExtension, turning it into the correct object type, and storing it
-// in the Object. (TODO: In the case where the object is of an unknown type, a
-// runtime.Unknown object will be created and stored.)
-//
-// +k8s:deepcopy-gen=true
-// +protobuf=true
-// +k8s:openapi-gen=true
-message RawExtension {
-  // Raw is the underlying serialization of this object.
-  //
-  // TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data.
-  optional bytes raw = 1;
-}
-
-// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
-// like this:
-// type MyAwesomeAPIObject struct {
-//      runtime.TypeMeta    `json:",inline"`
-//      ... // other fields
-// }
-// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
-//
-// TypeMeta is provided here for convenience. You may use it directly from this package or define
-// your own with the same fields.
-//
-// +k8s:deepcopy-gen=false
-// +protobuf=true
-// +k8s:openapi-gen=true
-message TypeMeta {
-  // +optional
-  optional string apiVersion = 1;
-
-  // +optional
-  optional string kind = 2;
-}
-
-// Unknown allows api objects with unknown types to be passed-through. This can be used
-// to deal with the API objects from a plug-in. Unknown objects still have functioning
-// TypeMeta features-- kind, version, etc.
-// TODO: Make this object have easy access to field based accessors and settors for
-// metadata and field mutatation.
-//
-// +k8s:deepcopy-gen=true
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +protobuf=true
-// +k8s:openapi-gen=true
-message Unknown {
-  optional TypeMeta typeMeta = 1;
-
-  // Raw will hold the complete serialized object which couldn't be matched
-  // with a registered type. Most likely, nothing should be done with this
-  // except for passing it through the system.
-  optional bytes raw = 2;
-
-  // ContentEncoding is encoding used to encode 'Raw' data.
-  // Unspecified means no encoding.
-  optional string contentEncoding = 3;
-
-  // ContentType  is serialization method used to serialize 'Raw'.
-  // Unspecified means ContentTypeJSON.
-  optional string contentType = 4;
-}
-
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/helper.go b/vendor/k8s.io/apimachinery/pkg/runtime/helper.go
deleted file mode 100644
index 7bd1a3a6a..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/helper.go
+++ /dev/null
@@ -1,259 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/errors"
-)
-
-// unsafeObjectConvertor implements ObjectConvertor using the unsafe conversion path.
-type unsafeObjectConvertor struct {
-	*Scheme
-}
-
-var _ ObjectConvertor = unsafeObjectConvertor{}
-
-// ConvertToVersion converts in to the provided outVersion without copying the input first, which
-// is only safe if the output object is not mutated or reused.
-func (c unsafeObjectConvertor) ConvertToVersion(in Object, outVersion GroupVersioner) (Object, error) {
-	return c.Scheme.UnsafeConvertToVersion(in, outVersion)
-}
-
-// UnsafeObjectConvertor performs object conversion without copying the object structure,
-// for use when the converted object will not be reused or mutated. Primarily for use within
-// versioned codecs, which use the external object for serialization but do not return it.
-func UnsafeObjectConvertor(scheme *Scheme) ObjectConvertor {
-	return unsafeObjectConvertor{scheme}
-}
-
-// SetField puts the value of src, into fieldName, which must be a member of v.
-// The value of src must be assignable to the field.
-func SetField(src interface{}, v reflect.Value, fieldName string) error {
-	field := v.FieldByName(fieldName)
-	if !field.IsValid() {
-		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
-	}
-	srcValue := reflect.ValueOf(src)
-	if srcValue.Type().AssignableTo(field.Type()) {
-		field.Set(srcValue)
-		return nil
-	}
-	if srcValue.Type().ConvertibleTo(field.Type()) {
-		field.Set(srcValue.Convert(field.Type()))
-		return nil
-	}
-	return fmt.Errorf("couldn't assign/convert %v to %v", srcValue.Type(), field.Type())
-}
-
-// Field puts the value of fieldName, which must be a member of v, into dest,
-// which must be a variable to which this field's value can be assigned.
-func Field(v reflect.Value, fieldName string, dest interface{}) error {
-	field := v.FieldByName(fieldName)
-	if !field.IsValid() {
-		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
-	}
-	destValue, err := conversion.EnforcePtr(dest)
-	if err != nil {
-		return err
-	}
-	if field.Type().AssignableTo(destValue.Type()) {
-		destValue.Set(field)
-		return nil
-	}
-	if field.Type().ConvertibleTo(destValue.Type()) {
-		destValue.Set(field.Convert(destValue.Type()))
-		return nil
-	}
-	return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), destValue.Type())
-}
-
-// FieldPtr puts the address of fieldName, which must be a member of v,
-// into dest, which must be an address of a variable to which this field's
-// address can be assigned.
-func FieldPtr(v reflect.Value, fieldName string, dest interface{}) error {
-	field := v.FieldByName(fieldName)
-	if !field.IsValid() {
-		return fmt.Errorf("couldn't find %v field in %T", fieldName, v.Interface())
-	}
-	v, err := conversion.EnforcePtr(dest)
-	if err != nil {
-		return err
-	}
-	field = field.Addr()
-	if field.Type().AssignableTo(v.Type()) {
-		v.Set(field)
-		return nil
-	}
-	if field.Type().ConvertibleTo(v.Type()) {
-		v.Set(field.Convert(v.Type()))
-		return nil
-	}
-	return fmt.Errorf("couldn't assign/convert %v to %v", field.Type(), v.Type())
-}
-
-// EncodeList ensures that each object in an array is converted to a Unknown{} in serialized form.
-// TODO: accept a content type.
-func EncodeList(e Encoder, objects []Object) error {
-	var errs []error
-	for i := range objects {
-		data, err := Encode(e, objects[i])
-		if err != nil {
-			errs = append(errs, err)
-			continue
-		}
-		// TODO: Set ContentEncoding and ContentType.
-		objects[i] = &Unknown{Raw: data}
-	}
-	return errors.NewAggregate(errs)
-}
-
-func decodeListItem(obj *Unknown, decoders []Decoder) (Object, error) {
-	for _, decoder := range decoders {
-		// TODO: Decode based on ContentType.
-		obj, err := Decode(decoder, obj.Raw)
-		if err != nil {
-			if IsNotRegisteredError(err) {
-				continue
-			}
-			return nil, err
-		}
-		return obj, nil
-	}
-	// could not decode, so leave the object as Unknown, but give the decoders the
-	// chance to set Unknown.TypeMeta if it is available.
-	for _, decoder := range decoders {
-		if err := DecodeInto(decoder, obj.Raw, obj); err == nil {
-			return obj, nil
-		}
-	}
-	return obj, nil
-}
-
-// DecodeList alters the list in place, attempting to decode any objects found in
-// the list that have the Unknown type. Any errors that occur are returned
-// after the entire list is processed. Decoders are tried in order.
-func DecodeList(objects []Object, decoders ...Decoder) []error {
-	errs := []error(nil)
-	for i, obj := range objects {
-		switch t := obj.(type) {
-		case *Unknown:
-			decoded, err := decodeListItem(t, decoders)
-			if err != nil {
-				errs = append(errs, err)
-				break
-			}
-			objects[i] = decoded
-		}
-	}
-	return errs
-}
-
-// MultiObjectTyper returns the types of objects across multiple schemes in order.
-type MultiObjectTyper []ObjectTyper
-
-var _ ObjectTyper = MultiObjectTyper{}
-
-func (m MultiObjectTyper) ObjectKinds(obj Object) (gvks []schema.GroupVersionKind, unversionedType bool, err error) {
-	for _, t := range m {
-		gvks, unversionedType, err = t.ObjectKinds(obj)
-		if err == nil {
-			return
-		}
-	}
-	return
-}
-
-func (m MultiObjectTyper) Recognizes(gvk schema.GroupVersionKind) bool {
-	for _, t := range m {
-		if t.Recognizes(gvk) {
-			return true
-		}
-	}
-	return false
-}
-
-// SetZeroValue would set the object of objPtr to zero value of its type.
-func SetZeroValue(objPtr Object) error {
-	v, err := conversion.EnforcePtr(objPtr)
-	if err != nil {
-		return err
-	}
-	v.Set(reflect.Zero(v.Type()))
-	return nil
-}
-
-// DefaultFramer is valid for any stream that can read objects serially without
-// any separation in the stream.
-var DefaultFramer = defaultFramer{}
-
-type defaultFramer struct{}
-
-func (defaultFramer) NewFrameReader(r io.ReadCloser) io.ReadCloser { return r }
-func (defaultFramer) NewFrameWriter(w io.Writer) io.Writer         { return w }
-
-// WithVersionEncoder serializes an object and ensures the GVK is set.
-type WithVersionEncoder struct {
-	Version GroupVersioner
-	Encoder
-	ObjectTyper
-}
-
-// Encode does not do conversion. It sets the gvk during serialization.
-func (e WithVersionEncoder) Encode(obj Object, stream io.Writer) error {
-	gvks, _, err := e.ObjectTyper.ObjectKinds(obj)
-	if err != nil {
-		if IsNotRegisteredError(err) {
-			return e.Encoder.Encode(obj, stream)
-		}
-		return err
-	}
-	kind := obj.GetObjectKind()
-	oldGVK := kind.GroupVersionKind()
-	gvk := gvks[0]
-	if e.Version != nil {
-		preferredGVK, ok := e.Version.KindForGroupVersionKinds(gvks)
-		if ok {
-			gvk = preferredGVK
-		}
-	}
-	kind.SetGroupVersionKind(gvk)
-	err = e.Encoder.Encode(obj, stream)
-	kind.SetGroupVersionKind(oldGVK)
-	return err
-}
-
-// WithoutVersionDecoder clears the group version kind of a deserialized object.
-type WithoutVersionDecoder struct {
-	Decoder
-}
-
-// Decode does not do conversion. It removes the gvk during deserialization.
-func (d WithoutVersionDecoder) Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error) {
-	obj, gvk, err := d.Decoder.Decode(data, defaults, into)
-	if obj != nil {
-		kind := obj.GetObjectKind()
-		// clearing the gvk is just a convention of a codec
-		kind.SetGroupVersionKind(schema.GroupVersionKind{})
-	}
-	return obj, gvk, err
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go b/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go
deleted file mode 100644
index 3e1fab1d1..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/interfaces.go
+++ /dev/null
@@ -1,344 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"io"
-	"net/url"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-const (
-	// APIVersionInternal may be used if you are registering a type that should not
-	// be considered stable or serialized - it is a convention only and has no
-	// special behavior in this package.
-	APIVersionInternal = "__internal"
-)
-
-// GroupVersioner refines a set of possible conversion targets into a single option.
-type GroupVersioner interface {
-	// KindForGroupVersionKinds returns a desired target group version kind for the given input, or returns ok false if no
-	// target is known. In general, if the return target is not in the input list, the caller is expected to invoke
-	// Scheme.New(target) and then perform a conversion between the current Go type and the destination Go type.
-	// Sophisticated implementations may use additional information about the input kinds to pick a destination kind.
-	KindForGroupVersionKinds(kinds []schema.GroupVersionKind) (target schema.GroupVersionKind, ok bool)
-	// Identifier returns string representation of the object.
-	// Identifiers of two different encoders should be equal only if for every input
-	// kinds they return the same result.
-	Identifier() string
-}
-
-// Identifier represents an identifier.
-// Identitier of two different objects should be equal if and only if for every
-// input the output they produce is exactly the same.
-type Identifier string
-
-// Encoder writes objects to a serialized form
-type Encoder interface {
-	// Encode writes an object to a stream. Implementations may return errors if the versions are
-	// incompatible, or if no conversion is defined.
-	Encode(obj Object, w io.Writer) error
-	// Identifier returns an identifier of the encoder.
-	// Identifiers of two different encoders should be equal if and only if for every input
-	// object it will be encoded to the same representation by both of them.
-	//
-	// Identifier is intended for use with CacheableObject#CacheEncode method. In order to
-	// correctly handle CacheableObject, Encode() method should look similar to below, where
-	// doEncode() is the encoding logic of implemented encoder:
-	//   func (e *MyEncoder) Encode(obj Object, w io.Writer) error {
-	//     if co, ok := obj.(CacheableObject); ok {
-	//       return co.CacheEncode(e.Identifier(), e.doEncode, w)
-	//     }
-	//     return e.doEncode(obj, w)
-	//   }
-	Identifier() Identifier
-}
-
-// Decoder attempts to load an object from data.
-type Decoder interface {
-	// Decode attempts to deserialize the provided data using either the innate typing of the scheme or the
-	// default kind, group, and version provided. It returns a decoded object as well as the kind, group, and
-	// version from the serialized data, or an error. If into is non-nil, it will be used as the target type
-	// and implementations may choose to use it rather than reallocating an object. However, the object is not
-	// guaranteed to be populated. The returned object is not guaranteed to match into. If defaults are
-	// provided, they are applied to the data by default. If no defaults or partial defaults are provided, the
-	// type of the into may be used to guide conversion decisions.
-	Decode(data []byte, defaults *schema.GroupVersionKind, into Object) (Object, *schema.GroupVersionKind, error)
-}
-
-// Serializer is the core interface for transforming objects into a serialized format and back.
-// Implementations may choose to perform conversion of the object, but no assumptions should be made.
-type Serializer interface {
-	Encoder
-	Decoder
-}
-
-// Codec is a Serializer that deals with the details of versioning objects. It offers the same
-// interface as Serializer, so this is a marker to consumers that care about the version of the objects
-// they receive.
-type Codec Serializer
-
-// ParameterCodec defines methods for serializing and deserializing API objects to url.Values and
-// performing any necessary conversion. Unlike the normal Codec, query parameters are not self describing
-// and the desired version must be specified.
-type ParameterCodec interface {
-	// DecodeParameters takes the given url.Values in the specified group version and decodes them
-	// into the provided object, or returns an error.
-	DecodeParameters(parameters url.Values, from schema.GroupVersion, into Object) error
-	// EncodeParameters encodes the provided object as query parameters or returns an error.
-	EncodeParameters(obj Object, to schema.GroupVersion) (url.Values, error)
-}
-
-// Framer is a factory for creating readers and writers that obey a particular framing pattern.
-type Framer interface {
-	NewFrameReader(r io.ReadCloser) io.ReadCloser
-	NewFrameWriter(w io.Writer) io.Writer
-}
-
-// SerializerInfo contains information about a specific serialization format
-type SerializerInfo struct {
-	// MediaType is the value that represents this serializer over the wire.
-	MediaType string
-	// MediaTypeType is the first part of the MediaType ("application" in "application/json").
-	MediaTypeType string
-	// MediaTypeSubType is the second part of the MediaType ("json" in "application/json").
-	MediaTypeSubType string
-	// EncodesAsText indicates this serializer can be encoded to UTF-8 safely.
-	EncodesAsText bool
-	// Serializer is the individual object serializer for this media type.
-	Serializer Serializer
-	// PrettySerializer, if set, can serialize this object in a form biased towards
-	// readability.
-	PrettySerializer Serializer
-	// StreamSerializer, if set, describes the streaming serialization format
-	// for this media type.
-	StreamSerializer *StreamSerializerInfo
-}
-
-// StreamSerializerInfo contains information about a specific stream serialization format
-type StreamSerializerInfo struct {
-	// EncodesAsText indicates this serializer can be encoded to UTF-8 safely.
-	EncodesAsText bool
-	// Serializer is the top level object serializer for this type when streaming
-	Serializer
-	// Framer is the factory for retrieving streams that separate objects on the wire
-	Framer
-}
-
-// NegotiatedSerializer is an interface used for obtaining encoders, decoders, and serializers
-// for multiple supported media types. This would commonly be accepted by a server component
-// that performs HTTP content negotiation to accept multiple formats.
-type NegotiatedSerializer interface {
-	// SupportedMediaTypes is the media types supported for reading and writing single objects.
-	SupportedMediaTypes() []SerializerInfo
-
-	// EncoderForVersion returns an encoder that ensures objects being written to the provided
-	// serializer are in the provided group version.
-	EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder
-	// DecoderForVersion returns a decoder that ensures objects being read by the provided
-	// serializer are in the provided group version by default.
-	DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder
-}
-
-// ClientNegotiator handles turning an HTTP content type into the appropriate encoder.
-// Use NewClientNegotiator or NewVersionedClientNegotiator to create this interface from
-// a NegotiatedSerializer.
-type ClientNegotiator interface {
-	// Encoder returns the appropriate encoder for the provided contentType (e.g. application/json)
-	// and any optional mediaType parameters (e.g. pretty=1), or an error. If no serializer is found
-	// a NegotiateError will be returned. The current client implementations consider params to be
-	// optional modifiers to the contentType and will ignore unrecognized parameters.
-	Encoder(contentType string, params map[string]string) (Encoder, error)
-	// Decoder returns the appropriate decoder for the provided contentType (e.g. application/json)
-	// and any optional mediaType parameters (e.g. pretty=1), or an error. If no serializer is found
-	// a NegotiateError will be returned. The current client implementations consider params to be
-	// optional modifiers to the contentType and will ignore unrecognized parameters.
-	Decoder(contentType string, params map[string]string) (Decoder, error)
-	// StreamDecoder returns the appropriate stream decoder for the provided contentType (e.g.
-	// application/json) and any optional mediaType parameters (e.g. pretty=1), or an error. If no
-	// serializer is found a NegotiateError will be returned. The Serializer and Framer will always
-	// be returned if a Decoder is returned. The current client implementations consider params to be
-	// optional modifiers to the contentType and will ignore unrecognized parameters.
-	StreamDecoder(contentType string, params map[string]string) (Decoder, Serializer, Framer, error)
-}
-
-// StorageSerializer is an interface used for obtaining encoders, decoders, and serializers
-// that can read and write data at rest. This would commonly be used by client tools that must
-// read files, or server side storage interfaces that persist restful objects.
-type StorageSerializer interface {
-	// SupportedMediaTypes are the media types supported for reading and writing objects.
-	SupportedMediaTypes() []SerializerInfo
-
-	// UniversalDeserializer returns a Serializer that can read objects in multiple supported formats
-	// by introspecting the data at rest.
-	UniversalDeserializer() Decoder
-
-	// EncoderForVersion returns an encoder that ensures objects being written to the provided
-	// serializer are in the provided group version.
-	EncoderForVersion(serializer Encoder, gv GroupVersioner) Encoder
-	// DecoderForVersion returns a decoder that ensures objects being read by the provided
-	// serializer are in the provided group version by default.
-	DecoderToVersion(serializer Decoder, gv GroupVersioner) Decoder
-}
-
-// NestedObjectEncoder is an optional interface that objects may implement to be given
-// an opportunity to encode any nested Objects / RawExtensions during serialization.
-type NestedObjectEncoder interface {
-	EncodeNestedObjects(e Encoder) error
-}
-
-// NestedObjectDecoder is an optional interface that objects may implement to be given
-// an opportunity to decode any nested Objects / RawExtensions during serialization.
-type NestedObjectDecoder interface {
-	DecodeNestedObjects(d Decoder) error
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// Non-codec interfaces
-
-type ObjectDefaulter interface {
-	// Default takes an object (must be a pointer) and applies any default values.
-	// Defaulters may not error.
-	Default(in Object)
-}
-
-type ObjectVersioner interface {
-	ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error)
-}
-
-// ObjectConvertor converts an object to a different version.
-type ObjectConvertor interface {
-	// Convert attempts to convert one object into another, or returns an error. This
-	// method does not mutate the in object, but the in and out object might share data structures,
-	// i.e. the out object cannot be mutated without mutating the in object as well.
-	// The context argument will be passed to all nested conversions.
-	Convert(in, out, context interface{}) error
-	// ConvertToVersion takes the provided object and converts it the provided version. This
-	// method does not mutate the in object, but the in and out object might share data structures,
-	// i.e. the out object cannot be mutated without mutating the in object as well.
-	// This method is similar to Convert() but handles specific details of choosing the correct
-	// output version.
-	ConvertToVersion(in Object, gv GroupVersioner) (out Object, err error)
-	ConvertFieldLabel(gvk schema.GroupVersionKind, label, value string) (string, string, error)
-}
-
-// ObjectTyper contains methods for extracting the APIVersion and Kind
-// of objects.
-type ObjectTyper interface {
-	// ObjectKinds returns the all possible group,version,kind of the provided object, true if
-	// the object is unversioned, or an error if the object is not recognized
-	// (IsNotRegisteredError will return true).
-	ObjectKinds(Object) ([]schema.GroupVersionKind, bool, error)
-	// Recognizes returns true if the scheme is able to handle the provided version and kind,
-	// or more precisely that the provided version is a possible conversion or decoding
-	// target.
-	Recognizes(gvk schema.GroupVersionKind) bool
-}
-
-// ObjectCreater contains methods for instantiating an object by kind and version.
-type ObjectCreater interface {
-	New(kind schema.GroupVersionKind) (out Object, err error)
-}
-
-// EquivalentResourceMapper provides information about resources that address the same underlying data as a specified resource
-type EquivalentResourceMapper interface {
-	// EquivalentResourcesFor returns a list of resources that address the same underlying data as resource.
-	// If subresource is specified, only equivalent resources which also have the same subresource are included.
-	// The specified resource can be included in the returned list.
-	EquivalentResourcesFor(resource schema.GroupVersionResource, subresource string) []schema.GroupVersionResource
-	// KindFor returns the kind expected by the specified resource[/subresource].
-	// A zero value is returned if the kind is unknown.
-	KindFor(resource schema.GroupVersionResource, subresource string) schema.GroupVersionKind
-}
-
-// EquivalentResourceRegistry provides an EquivalentResourceMapper interface,
-// and allows registering known resource[/subresource] -> kind
-type EquivalentResourceRegistry interface {
-	EquivalentResourceMapper
-	// RegisterKindFor registers the existence of the specified resource[/subresource] along with its expected kind.
-	RegisterKindFor(resource schema.GroupVersionResource, subresource string, kind schema.GroupVersionKind)
-}
-
-// ResourceVersioner provides methods for setting and retrieving
-// the resource version from an API object.
-type ResourceVersioner interface {
-	SetResourceVersion(obj Object, version string) error
-	ResourceVersion(obj Object) (string, error)
-}
-
-// SelfLinker provides methods for setting and retrieving the SelfLink field of an API object.
-type SelfLinker interface {
-	SetSelfLink(obj Object, selfLink string) error
-	SelfLink(obj Object) (string, error)
-
-	// Knowing Name is sometimes necessary to use a SelfLinker.
-	Name(obj Object) (string, error)
-	// Knowing Namespace is sometimes necessary to use a SelfLinker
-	Namespace(obj Object) (string, error)
-}
-
-// Object interface must be supported by all API types registered with Scheme. Since objects in a scheme are
-// expected to be serialized to the wire, the interface an Object must provide to the Scheme allows
-// serializers to set the kind, version, and group the object is represented as. An Object may choose
-// to return a no-op ObjectKindAccessor in cases where it is not expected to be serialized.
-type Object interface {
-	GetObjectKind() schema.ObjectKind
-	DeepCopyObject() Object
-}
-
-// CacheableObject allows an object to cache its different serializations
-// to avoid performing the same serialization multiple times.
-type CacheableObject interface {
-	// CacheEncode writes an object to a stream. The <encode> function will
-	// be used in case of cache miss. The <encode> function takes ownership
-	// of the object.
-	// If CacheableObject is a wrapper, then deep-copy of the wrapped object
-	// should be passed to <encode> function.
-	// CacheEncode assumes that for two different calls with the same <id>,
-	// <encode> function will also be the same.
-	CacheEncode(id Identifier, encode func(Object, io.Writer) error, w io.Writer) error
-	// GetObject returns a deep-copy of an object to be encoded - the caller of
-	// GetObject() is the owner of returned object. The reason for making a copy
-	// is to avoid bugs, where caller modifies the object and forgets to copy it,
-	// thus modifying the object for everyone.
-	// The object returned by GetObject should be the same as the one that is supposed
-	// to be passed to <encode> function in CacheEncode method.
-	// If CacheableObject is a wrapper, the copy of wrapped object should be returned.
-	GetObject() Object
-}
-
-// Unstructured objects store values as map[string]interface{}, with only values that can be serialized
-// to JSON allowed.
-type Unstructured interface {
-	Object
-	// NewEmptyInstance returns a new instance of the concrete type containing only kind/apiVersion and no other data.
-	// This should be called instead of reflect.New() for unstructured types because the go type alone does not preserve kind/apiVersion info.
-	NewEmptyInstance() Unstructured
-	// UnstructuredContent returns a non-nil map with this object's contents. Values may be
-	// []interface{}, map[string]interface{}, or any primitive type. Contents are typically serialized to
-	// and from JSON. SetUnstructuredContent should be used to mutate the contents.
-	UnstructuredContent() map[string]interface{}
-	// SetUnstructuredContent updates the object content to match the provided map.
-	SetUnstructuredContent(map[string]interface{})
-	// IsList returns true if this type is a list or matches the list convention - has an array called "items".
-	IsList() bool
-	// EachListItem should pass a single item out of the list as an Object to the provided function. Any
-	// error should terminate the iteration. If IsList() returns false, this method should return an error
-	// instead of calling the provided function.
-	EachListItem(func(Object) error) error
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go b/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go
deleted file mode 100644
index 3ff84611a..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/mapper.go
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-Copyright 2019 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 runtime
-
-import (
-	"sync"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-type equivalentResourceRegistry struct {
-	// keyFunc computes a key for the specified resource (this allows honoring colocated resources across API groups).
-	// if null, or if "" is returned, resource.String() is used as the key
-	keyFunc func(resource schema.GroupResource) string
-	// resources maps key -> subresource -> equivalent resources (subresource is not included in the returned resources).
-	// main resources are stored with subresource="".
-	resources map[string]map[string][]schema.GroupVersionResource
-	// kinds maps resource -> subresource -> kind
-	kinds map[schema.GroupVersionResource]map[string]schema.GroupVersionKind
-	// keys caches the computed key for each GroupResource
-	keys map[schema.GroupResource]string
-
-	mutex sync.RWMutex
-}
-
-var _ EquivalentResourceMapper = (*equivalentResourceRegistry)(nil)
-var _ EquivalentResourceRegistry = (*equivalentResourceRegistry)(nil)
-
-// NewEquivalentResourceRegistry creates a resource registry that considers all versions of a GroupResource to be equivalent.
-func NewEquivalentResourceRegistry() EquivalentResourceRegistry {
-	return &equivalentResourceRegistry{}
-}
-
-// NewEquivalentResourceRegistryWithIdentity creates a resource mapper with a custom identity function.
-// If "" is returned by the function, GroupResource#String is used as the identity.
-// GroupResources with the same identity string are considered equivalent.
-func NewEquivalentResourceRegistryWithIdentity(keyFunc func(schema.GroupResource) string) EquivalentResourceRegistry {
-	return &equivalentResourceRegistry{keyFunc: keyFunc}
-}
-
-func (r *equivalentResourceRegistry) EquivalentResourcesFor(resource schema.GroupVersionResource, subresource string) []schema.GroupVersionResource {
-	r.mutex.RLock()
-	defer r.mutex.RUnlock()
-	return r.resources[r.keys[resource.GroupResource()]][subresource]
-}
-func (r *equivalentResourceRegistry) KindFor(resource schema.GroupVersionResource, subresource string) schema.GroupVersionKind {
-	r.mutex.RLock()
-	defer r.mutex.RUnlock()
-	return r.kinds[resource][subresource]
-}
-func (r *equivalentResourceRegistry) RegisterKindFor(resource schema.GroupVersionResource, subresource string, kind schema.GroupVersionKind) {
-	r.mutex.Lock()
-	defer r.mutex.Unlock()
-	if r.kinds == nil {
-		r.kinds = map[schema.GroupVersionResource]map[string]schema.GroupVersionKind{}
-	}
-	if r.kinds[resource] == nil {
-		r.kinds[resource] = map[string]schema.GroupVersionKind{}
-	}
-	r.kinds[resource][subresource] = kind
-
-	// get the shared key of the parent resource
-	key := ""
-	gr := resource.GroupResource()
-	if r.keyFunc != nil {
-		key = r.keyFunc(gr)
-	}
-	if key == "" {
-		key = gr.String()
-	}
-
-	if r.keys == nil {
-		r.keys = map[schema.GroupResource]string{}
-	}
-	r.keys[gr] = key
-
-	if r.resources == nil {
-		r.resources = map[string]map[string][]schema.GroupVersionResource{}
-	}
-	if r.resources[key] == nil {
-		r.resources[key] = map[string][]schema.GroupVersionResource{}
-	}
-	r.resources[key][subresource] = append(r.resources[key][subresource], resource)
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go b/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go
deleted file mode 100644
index 3ab119b0a..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/negotiate.go
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-Copyright 2019 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 runtime
-
-import (
-	"fmt"
-
-	"k8s.io/apimachinery/pkg/runtime/schema"
-)
-
-// NegotiateError is returned when a ClientNegotiator is unable to locate
-// a serializer for the requested operation.
-type NegotiateError struct {
-	ContentType string
-	Stream      bool
-}
-
-func (e NegotiateError) Error() string {
-	if e.Stream {
-		return fmt.Sprintf("no stream serializers registered for %s", e.ContentType)
-	}
-	return fmt.Sprintf("no serializers registered for %s", e.ContentType)
-}
-
-type clientNegotiator struct {
-	serializer     NegotiatedSerializer
-	encode, decode GroupVersioner
-}
-
-func (n *clientNegotiator) Encoder(contentType string, params map[string]string) (Encoder, error) {
-	// TODO: `pretty=1` is handled in NegotiateOutputMediaType, consider moving it to this method
-	// if client negotiators truly need to use it
-	mediaTypes := n.serializer.SupportedMediaTypes()
-	info, ok := SerializerInfoForMediaType(mediaTypes, contentType)
-	if !ok {
-		if len(contentType) != 0 || len(mediaTypes) == 0 {
-			return nil, NegotiateError{ContentType: contentType}
-		}
-		info = mediaTypes[0]
-	}
-	return n.serializer.EncoderForVersion(info.Serializer, n.encode), nil
-}
-
-func (n *clientNegotiator) Decoder(contentType string, params map[string]string) (Decoder, error) {
-	mediaTypes := n.serializer.SupportedMediaTypes()
-	info, ok := SerializerInfoForMediaType(mediaTypes, contentType)
-	if !ok {
-		if len(contentType) != 0 || len(mediaTypes) == 0 {
-			return nil, NegotiateError{ContentType: contentType}
-		}
-		info = mediaTypes[0]
-	}
-	return n.serializer.DecoderToVersion(info.Serializer, n.decode), nil
-}
-
-func (n *clientNegotiator) StreamDecoder(contentType string, params map[string]string) (Decoder, Serializer, Framer, error) {
-	mediaTypes := n.serializer.SupportedMediaTypes()
-	info, ok := SerializerInfoForMediaType(mediaTypes, contentType)
-	if !ok {
-		if len(contentType) != 0 || len(mediaTypes) == 0 {
-			return nil, nil, nil, NegotiateError{ContentType: contentType, Stream: true}
-		}
-		info = mediaTypes[0]
-	}
-	if info.StreamSerializer == nil {
-		return nil, nil, nil, NegotiateError{ContentType: info.MediaType, Stream: true}
-	}
-	return n.serializer.DecoderToVersion(info.Serializer, n.decode), info.StreamSerializer.Serializer, info.StreamSerializer.Framer, nil
-}
-
-// NewClientNegotiator will attempt to retrieve the appropriate encoder, decoder, or
-// stream decoder for a given content type. Does not perform any conversion, but will
-// encode the object to the desired group, version, and kind. Use when creating a client.
-func NewClientNegotiator(serializer NegotiatedSerializer, gv schema.GroupVersion) ClientNegotiator {
-	return &clientNegotiator{
-		serializer: serializer,
-		encode:     gv,
-	}
-}
-
-type simpleNegotiatedSerializer struct {
-	info SerializerInfo
-}
-
-func NewSimpleNegotiatedSerializer(info SerializerInfo) NegotiatedSerializer {
-	return &simpleNegotiatedSerializer{info: info}
-}
-
-func (n *simpleNegotiatedSerializer) SupportedMediaTypes() []SerializerInfo {
-	return []SerializerInfo{n.info}
-}
-
-func (n *simpleNegotiatedSerializer) EncoderForVersion(e Encoder, _ GroupVersioner) Encoder {
-	return e
-}
-
-func (n *simpleNegotiatedSerializer) DecoderToVersion(d Decoder, _gv GroupVersioner) Decoder {
-	return d
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/register.go b/vendor/k8s.io/apimachinery/pkg/runtime/register.go
deleted file mode 100644
index 1cd2e4c38..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/register.go
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-Copyright 2015 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 runtime
-
-import "k8s.io/apimachinery/pkg/runtime/schema"
-
-// SetGroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) SetGroupVersionKind(gvk schema.GroupVersionKind) {
-	obj.APIVersion, obj.Kind = gvk.ToAPIVersionAndKind()
-}
-
-// GroupVersionKind satisfies the ObjectKind interface for all objects that embed TypeMeta
-func (obj *TypeMeta) GroupVersionKind() schema.GroupVersionKind {
-	return schema.FromAPIVersionAndKind(obj.APIVersion, obj.Kind)
-}
-
-func (obj *TypeMeta) GetObjectKind() schema.ObjectKind { return obj }
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go
deleted file mode 100644
index 29d3ac45b..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.pb.go
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto
-
-package schema
-
-import (
-	fmt "fmt"
-
-	math "math"
-
-	proto "github.com/gogo/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-func init() {
-	proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto", fileDescriptor_0462724132518e0d)
-}
-
-var fileDescriptor_0462724132518e0d = []byte{
-	// 185 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x4c, 0xcc, 0xaf, 0x6e, 0xc3, 0x30,
-	0x10, 0xc7, 0x71, 0x9b, 0x0c, 0x0c, 0x0e, 0x0e, 0x1c, 0x1c, 0xda, 0x7c, 0x74, 0xb8, 0x2f, 0x50,
-	0x5e, 0xe6, 0x24, 0x57, 0xc7, 0xb2, 0xfc, 0x47, 0x8e, 0x5d, 0xa9, 0xac, 0x8f, 0xd0, 0xc7, 0x0a,
-	0x0c, 0x0c, 0x6c, 0xdc, 0x17, 0xa9, 0x64, 0x07, 0x94, 0xdd, 0x4f, 0xa7, 0xcf, 0xf7, 0xf3, 0x68,
-	0xfe, 0x27, 0xa1, 0x3d, 0x9a, 0xdc, 0x51, 0x74, 0x94, 0x68, 0xc2, 0x0b, 0xb9, 0xc1, 0x47, 0xdc,
-	0x1f, 0x32, 0x68, 0x2b, 0xfb, 0x51, 0x3b, 0x8a, 0x57, 0x0c, 0x46, 0x61, 0xcc, 0x2e, 0x69, 0x4b,
-	0x38, 0xf5, 0x23, 0x59, 0x89, 0x8a, 0x1c, 0x45, 0x99, 0x68, 0x10, 0x21, 0xfa, 0xe4, 0xbf, 0x7e,
-	0x9a, 0x13, 0xef, 0x4e, 0x04, 0xa3, 0xc4, 0xee, 0x44, 0x73, 0xdf, 0x7f, 0x4a, 0xa7, 0x31, 0x77,
-	0xa2, 0xf7, 0x16, 0x95, 0x57, 0x1e, 0x2b, 0xef, 0xf2, 0xb9, 0xae, 0x3a, 0xea, 0xd5, 0xb2, 0x87,
-	0xdf, 0x79, 0x03, 0xb6, 0x6c, 0xc0, 0xd6, 0x0d, 0xd8, 0xad, 0x00, 0x9f, 0x0b, 0xf0, 0xa5, 0x00,
-	0x5f, 0x0b, 0xf0, 0x47, 0x01, 0x7e, 0x7f, 0x02, 0x3b, 0x7d, 0xb4, 0xf8, 0x2b, 0x00, 0x00, 0xff,
-	0xff, 0xba, 0x7e, 0x65, 0xf4, 0xd6, 0x00, 0x00, 0x00,
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto b/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto
deleted file mode 100644
index c50766a4b..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/generated.proto
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-
-// This file was autogenerated by go-to-protobuf. Do not edit it manually!
-
-syntax = "proto2";
-
-package k8s.io.apimachinery.pkg.runtime.schema;
-
-// Package-wide variables from generator "generated".
-option go_package = "schema";
-
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go
deleted file mode 100644
index 994a3e3fa..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/group_version.go
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
-Copyright 2015 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 schema
-
-import (
-	"fmt"
-	"strings"
-)
-
-// ParseResourceArg takes the common style of string which may be either `resource.group.com` or `resource.version.group.com`
-// and parses it out into both possibilities.  This code takes no responsibility for knowing which representation was intended
-// but with a knowledge of all GroupVersions, calling code can take a very good guess.  If there are only two segments, then
-// `*GroupVersionResource` is nil.
-// `resource.group.com` -> `group=com, version=group, resource=resource` and `group=group.com, resource=resource`
-func ParseResourceArg(arg string) (*GroupVersionResource, GroupResource) {
-	var gvr *GroupVersionResource
-	if strings.Count(arg, ".") >= 2 {
-		s := strings.SplitN(arg, ".", 3)
-		gvr = &GroupVersionResource{Group: s[2], Version: s[1], Resource: s[0]}
-	}
-
-	return gvr, ParseGroupResource(arg)
-}
-
-// ParseKindArg takes the common style of string which may be either `Kind.group.com` or `Kind.version.group.com`
-// and parses it out into both possibilities. This code takes no responsibility for knowing which representation was intended
-// but with a knowledge of all GroupKinds, calling code can take a very good guess. If there are only two segments, then
-// `*GroupVersionResource` is nil.
-// `Kind.group.com` -> `group=com, version=group, kind=Kind` and `group=group.com, kind=Kind`
-func ParseKindArg(arg string) (*GroupVersionKind, GroupKind) {
-	var gvk *GroupVersionKind
-	if strings.Count(arg, ".") >= 2 {
-		s := strings.SplitN(arg, ".", 3)
-		gvk = &GroupVersionKind{Group: s[2], Version: s[1], Kind: s[0]}
-	}
-
-	return gvk, ParseGroupKind(arg)
-}
-
-// GroupResource specifies a Group and a Resource, but does not force a version.  This is useful for identifying
-// concepts during lookup stages without having partially valid types
-type GroupResource struct {
-	Group    string
-	Resource string
-}
-
-func (gr GroupResource) WithVersion(version string) GroupVersionResource {
-	return GroupVersionResource{Group: gr.Group, Version: version, Resource: gr.Resource}
-}
-
-func (gr GroupResource) Empty() bool {
-	return len(gr.Group) == 0 && len(gr.Resource) == 0
-}
-
-func (gr GroupResource) String() string {
-	if len(gr.Group) == 0 {
-		return gr.Resource
-	}
-	return gr.Resource + "." + gr.Group
-}
-
-func ParseGroupKind(gk string) GroupKind {
-	i := strings.Index(gk, ".")
-	if i == -1 {
-		return GroupKind{Kind: gk}
-	}
-
-	return GroupKind{Group: gk[i+1:], Kind: gk[:i]}
-}
-
-// ParseGroupResource turns "resource.group" string into a GroupResource struct.  Empty strings are allowed
-// for each field.
-func ParseGroupResource(gr string) GroupResource {
-	if i := strings.Index(gr, "."); i >= 0 {
-		return GroupResource{Group: gr[i+1:], Resource: gr[:i]}
-	}
-	return GroupResource{Resource: gr}
-}
-
-// GroupVersionResource unambiguously identifies a resource.  It doesn't anonymously include GroupVersion
-// to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
-type GroupVersionResource struct {
-	Group    string
-	Version  string
-	Resource string
-}
-
-func (gvr GroupVersionResource) Empty() bool {
-	return len(gvr.Group) == 0 && len(gvr.Version) == 0 && len(gvr.Resource) == 0
-}
-
-func (gvr GroupVersionResource) GroupResource() GroupResource {
-	return GroupResource{Group: gvr.Group, Resource: gvr.Resource}
-}
-
-func (gvr GroupVersionResource) GroupVersion() GroupVersion {
-	return GroupVersion{Group: gvr.Group, Version: gvr.Version}
-}
-
-func (gvr GroupVersionResource) String() string {
-	return strings.Join([]string{gvr.Group, "/", gvr.Version, ", Resource=", gvr.Resource}, "")
-}
-
-// GroupKind specifies a Group and a Kind, but does not force a version.  This is useful for identifying
-// concepts during lookup stages without having partially valid types
-type GroupKind struct {
-	Group string
-	Kind  string
-}
-
-func (gk GroupKind) Empty() bool {
-	return len(gk.Group) == 0 && len(gk.Kind) == 0
-}
-
-func (gk GroupKind) WithVersion(version string) GroupVersionKind {
-	return GroupVersionKind{Group: gk.Group, Version: version, Kind: gk.Kind}
-}
-
-func (gk GroupKind) String() string {
-	if len(gk.Group) == 0 {
-		return gk.Kind
-	}
-	return gk.Kind + "." + gk.Group
-}
-
-// GroupVersionKind unambiguously identifies a kind.  It doesn't anonymously include GroupVersion
-// to avoid automatic coercion.  It doesn't use a GroupVersion to avoid custom marshalling
-type GroupVersionKind struct {
-	Group   string
-	Version string
-	Kind    string
-}
-
-// Empty returns true if group, version, and kind are empty
-func (gvk GroupVersionKind) Empty() bool {
-	return len(gvk.Group) == 0 && len(gvk.Version) == 0 && len(gvk.Kind) == 0
-}
-
-func (gvk GroupVersionKind) GroupKind() GroupKind {
-	return GroupKind{Group: gvk.Group, Kind: gvk.Kind}
-}
-
-func (gvk GroupVersionKind) GroupVersion() GroupVersion {
-	return GroupVersion{Group: gvk.Group, Version: gvk.Version}
-}
-
-func (gvk GroupVersionKind) String() string {
-	return gvk.Group + "/" + gvk.Version + ", Kind=" + gvk.Kind
-}
-
-// GroupVersion contains the "group" and the "version", which uniquely identifies the API.
-type GroupVersion struct {
-	Group   string
-	Version string
-}
-
-// Empty returns true if group and version are empty
-func (gv GroupVersion) Empty() bool {
-	return len(gv.Group) == 0 && len(gv.Version) == 0
-}
-
-// String puts "group" and "version" into a single "group/version" string. For the legacy v1
-// it returns "v1".
-func (gv GroupVersion) String() string {
-	if len(gv.Group) > 0 {
-		return gv.Group + "/" + gv.Version
-	}
-	return gv.Version
-}
-
-// Identifier implements runtime.GroupVersioner interface.
-func (gv GroupVersion) Identifier() string {
-	return gv.String()
-}
-
-// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false
-// if none of the options match the group. It prefers a match to group and version over just group.
-// TODO: Move GroupVersion to a package under pkg/runtime, since it's used by scheme.
-// TODO: Introduce an adapter type between GroupVersion and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
-//   in fewer places.
-func (gv GroupVersion) KindForGroupVersionKinds(kinds []GroupVersionKind) (target GroupVersionKind, ok bool) {
-	for _, gvk := range kinds {
-		if gvk.Group == gv.Group && gvk.Version == gv.Version {
-			return gvk, true
-		}
-	}
-	for _, gvk := range kinds {
-		if gvk.Group == gv.Group {
-			return gv.WithKind(gvk.Kind), true
-		}
-	}
-	return GroupVersionKind{}, false
-}
-
-// ParseGroupVersion turns "group/version" string into a GroupVersion struct. It reports error
-// if it cannot parse the string.
-func ParseGroupVersion(gv string) (GroupVersion, error) {
-	// this can be the internal version for the legacy kube types
-	// TODO once we've cleared the last uses as strings, this special case should be removed.
-	if (len(gv) == 0) || (gv == "/") {
-		return GroupVersion{}, nil
-	}
-
-	switch strings.Count(gv, "/") {
-	case 0:
-		return GroupVersion{"", gv}, nil
-	case 1:
-		i := strings.Index(gv, "/")
-		return GroupVersion{gv[:i], gv[i+1:]}, nil
-	default:
-		return GroupVersion{}, fmt.Errorf("unexpected GroupVersion string: %v", gv)
-	}
-}
-
-// WithKind creates a GroupVersionKind based on the method receiver's GroupVersion and the passed Kind.
-func (gv GroupVersion) WithKind(kind string) GroupVersionKind {
-	return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
-}
-
-// WithResource creates a GroupVersionResource based on the method receiver's GroupVersion and the passed Resource.
-func (gv GroupVersion) WithResource(resource string) GroupVersionResource {
-	return GroupVersionResource{Group: gv.Group, Version: gv.Version, Resource: resource}
-}
-
-// GroupVersions can be used to represent a set of desired group versions.
-// TODO: Move GroupVersions to a package under pkg/runtime, since it's used by scheme.
-// TODO: Introduce an adapter type between GroupVersions and runtime.GroupVersioner, and use LegacyCodec(GroupVersion)
-//   in fewer places.
-type GroupVersions []GroupVersion
-
-// Identifier implements runtime.GroupVersioner interface.
-func (gvs GroupVersions) Identifier() string {
-	groupVersions := make([]string, 0, len(gvs))
-	for i := range gvs {
-		groupVersions = append(groupVersions, gvs[i].String())
-	}
-	return fmt.Sprintf("[%s]", strings.Join(groupVersions, ","))
-}
-
-// KindForGroupVersionKinds identifies the preferred GroupVersionKind out of a list. It returns ok false
-// if none of the options match the group.
-func (gvs GroupVersions) KindForGroupVersionKinds(kinds []GroupVersionKind) (GroupVersionKind, bool) {
-	var targets []GroupVersionKind
-	for _, gv := range gvs {
-		target, ok := gv.KindForGroupVersionKinds(kinds)
-		if !ok {
-			continue
-		}
-		targets = append(targets, target)
-	}
-	if len(targets) == 1 {
-		return targets[0], true
-	}
-	if len(targets) > 1 {
-		return bestMatch(kinds, targets), true
-	}
-	return GroupVersionKind{}, false
-}
-
-// bestMatch tries to pick best matching GroupVersionKind and falls back to the first
-// found if no exact match exists.
-func bestMatch(kinds []GroupVersionKind, targets []GroupVersionKind) GroupVersionKind {
-	for _, gvk := range targets {
-		for _, k := range kinds {
-			if k == gvk {
-				return k
-			}
-		}
-	}
-	return targets[0]
-}
-
-// ToAPIVersionAndKind is a convenience method for satisfying runtime.Object on types that
-// do not use TypeMeta.
-func (gvk GroupVersionKind) ToAPIVersionAndKind() (string, string) {
-	if gvk.Empty() {
-		return "", ""
-	}
-	return gvk.GroupVersion().String(), gvk.Kind
-}
-
-// FromAPIVersionAndKind returns a GVK representing the provided fields for types that
-// do not use TypeMeta. This method exists to support test types and legacy serializations
-// that have a distinct group and kind.
-// TODO: further reduce usage of this method.
-func FromAPIVersionAndKind(apiVersion, kind string) GroupVersionKind {
-	if gv, err := ParseGroupVersion(apiVersion); err == nil {
-		return GroupVersionKind{Group: gv.Group, Version: gv.Version, Kind: kind}
-	}
-	return GroupVersionKind{Kind: kind}
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go b/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go
deleted file mode 100644
index f04453fb0..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/schema/interfaces.go
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package schema
-
-// All objects that are serialized from a Scheme encode their type information. This interface is used
-// by serialization to set type information from the Scheme onto the serialized version of an object.
-// For objects that cannot be serialized or have unique requirements, this interface may be a no-op.
-type ObjectKind interface {
-	// SetGroupVersionKind sets or clears the intended serialized kind of an object. Passing kind nil
-	// should clear the current setting.
-	SetGroupVersionKind(kind GroupVersionKind)
-	// GroupVersionKind returns the stored group, version, and kind of an object, or an empty struct
-	// if the object does not expose or provide these fields.
-	GroupVersionKind() GroupVersionKind
-}
-
-// EmptyObjectKind implements the ObjectKind interface as a noop
-var EmptyObjectKind = emptyObjectKind{}
-
-type emptyObjectKind struct{}
-
-// SetGroupVersionKind implements the ObjectKind interface
-func (emptyObjectKind) SetGroupVersionKind(gvk GroupVersionKind) {}
-
-// GroupVersionKind implements the ObjectKind interface
-func (emptyObjectKind) GroupVersionKind() GroupVersionKind { return GroupVersionKind{} }
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go b/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go
deleted file mode 100644
index ae47ab3ab..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/scheme.go
+++ /dev/null
@@ -1,728 +0,0 @@
-/*
-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.
-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 runtime
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"k8s.io/apimachinery/pkg/conversion"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/naming"
-	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
-	"k8s.io/apimachinery/pkg/util/sets"
-)
-
-// Scheme defines methods for serializing and deserializing API objects, a type
-// registry for converting group, version, and kind information to and from Go
-// schemas, and mappings between Go schemas of different versions. A scheme is the
-// foundation for a versioned API and versioned configuration over time.
-//
-// In a Scheme, a Type is a particular Go struct, a Version is a point-in-time
-// identifier for a particular representation of that Type (typically backwards
-// compatible), a Kind is the unique name for that Type within the Version, and a
-// Group identifies a set of Versions, Kinds, and Types that evolve over time. An
-// Unversioned Type is one that is not yet formally bound to a type and is promised
-// to be backwards compatible (effectively a "v1" of a Type that does not expect
-// to break in the future).
-//
-// Schemes are not expected to change at runtime and are only threadsafe after
-// registration is complete.
-type Scheme struct {
-	// versionMap allows one to figure out the go type of an object with
-	// the given version and name.
-	gvkToType map[schema.GroupVersionKind]reflect.Type
-
-	// typeToGroupVersion allows one to find metadata for a given go object.
-	// The reflect.Type we index by should *not* be a pointer.
-	typeToGVK map[reflect.Type][]schema.GroupVersionKind
-
-	// unversionedTypes are transformed without conversion in ConvertToVersion.
-	unversionedTypes map[reflect.Type]schema.GroupVersionKind
-
-	// unversionedKinds are the names of kinds that can be created in the context of any group
-	// or version
-	// TODO: resolve the status of unversioned types.
-	unversionedKinds map[string]reflect.Type
-
-	// Map from version and resource to the corresponding func to convert
-	// resource field labels in that version to internal version.
-	fieldLabelConversionFuncs map[schema.GroupVersionKind]FieldLabelConversionFunc
-
-	// defaulterFuncs is an array of interfaces to be called with an object to provide defaulting
-	// the provided object must be a pointer.
-	defaulterFuncs map[reflect.Type]func(interface{})
-
-	// converter stores all registered conversion functions. It also has
-	// default converting behavior.
-	converter *conversion.Converter
-
-	// versionPriority is a map of groups to ordered lists of versions for those groups indicating the
-	// default priorities of these versions as registered in the scheme
-	versionPriority map[string][]string
-
-	// observedVersions keeps track of the order we've seen versions during type registration
-	observedVersions []schema.GroupVersion
-
-	// schemeName is the name of this scheme.  If you don't specify a name, the stack of the NewScheme caller will be used.
-	// This is useful for error reporting to indicate the origin of the scheme.
-	schemeName string
-}
-
-// FieldLabelConversionFunc converts a field selector to internal representation.
-type FieldLabelConversionFunc func(label, value string) (internalLabel, internalValue string, err error)
-
-// NewScheme creates a new Scheme. This scheme is pluggable by default.
-func NewScheme() *Scheme {
-	s := &Scheme{
-		gvkToType:                 map[schema.GroupVersionKind]reflect.Type{},
-		typeToGVK:                 map[reflect.Type][]schema.GroupVersionKind{},
-		unversionedTypes:          map[reflect.Type]schema.GroupVersionKind{},
-		unversionedKinds:          map[string]reflect.Type{},
-		fieldLabelConversionFuncs: map[schema.GroupVersionKind]FieldLabelConversionFunc{},
-		defaulterFuncs:            map[reflect.Type]func(interface{}){},
-		versionPriority:           map[string][]string{},
-		schemeName:                naming.GetNameFromCallsite(internalPackages...),
-	}
-	s.converter = conversion.NewConverter(s.nameFunc)
-
-	// Enable couple default conversions by default.
-	utilruntime.Must(RegisterEmbeddedConversions(s))
-	utilruntime.Must(RegisterStringConversions(s))
-	return s
-}
-
-// nameFunc returns the name of the type that we wish to use to determine when two types attempt
-// a conversion. Defaults to the go name of the type if the type is not registered.
-func (s *Scheme) nameFunc(t reflect.Type) string {
-	// find the preferred names for this type
-	gvks, ok := s.typeToGVK[t]
-	if !ok {
-		return t.Name()
-	}
-
-	for _, gvk := range gvks {
-		internalGV := gvk.GroupVersion()
-		internalGV.Version = APIVersionInternal // this is hacky and maybe should be passed in
-		internalGVK := internalGV.WithKind(gvk.Kind)
-
-		if internalType, exists := s.gvkToType[internalGVK]; exists {
-			return s.typeToGVK[internalType][0].Kind
-		}
-	}
-
-	return gvks[0].Kind
-}
-
-// Converter allows access to the converter for the scheme
-func (s *Scheme) Converter() *conversion.Converter {
-	return s.converter
-}
-
-// AddUnversionedTypes registers the provided types as "unversioned", which means that they follow special rules.
-// Whenever an object of this type is serialized, it is serialized with the provided group version and is not
-// converted. Thus unversioned objects are expected to remain backwards compatible forever, as if they were in an
-// API group and version that would never be updated.
-//
-// TODO: there is discussion about removing unversioned and replacing it with objects that are manifest into
-//   every version with particular schemas. Resolve this method at that point.
-func (s *Scheme) AddUnversionedTypes(version schema.GroupVersion, types ...Object) {
-	s.addObservedVersion(version)
-	s.AddKnownTypes(version, types...)
-	for _, obj := range types {
-		t := reflect.TypeOf(obj).Elem()
-		gvk := version.WithKind(t.Name())
-		s.unversionedTypes[t] = gvk
-		if old, ok := s.unversionedKinds[gvk.Kind]; ok && t != old {
-			panic(fmt.Sprintf("%v.%v has already been registered as unversioned kind %q - kind name must be unique in scheme %q", old.PkgPath(), old.Name(), gvk, s.schemeName))
-		}
-		s.unversionedKinds[gvk.Kind] = t
-	}
-}
-
-// AddKnownTypes registers all types passed in 'types' as being members of version 'version'.
-// All objects passed to types should be pointers to structs. The name that go reports for
-// the struct becomes the "kind" field when encoding. Version may not be empty - use the
-// APIVersionInternal constant if you have a type that does not have a formal version.
-func (s *Scheme) AddKnownTypes(gv schema.GroupVersion, types ...Object) {
-	s.addObservedVersion(gv)
-	for _, obj := range types {
-		t := reflect.TypeOf(obj)
-		if t.Kind() != reflect.Ptr {
-			panic("All types must be pointers to structs.")
-		}
-		t = t.Elem()
-		s.AddKnownTypeWithName(gv.WithKind(t.Name()), obj)
-	}
-}
-
-// AddKnownTypeWithName is like AddKnownTypes, but it lets you specify what this type should
-// be encoded as. Useful for testing when you don't want to make multiple packages to define
-// your structs. Version may not be empty - use the APIVersionInternal constant if you have a
-// type that does not have a formal version.
-func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object) {
-	s.addObservedVersion(gvk.GroupVersion())
-	t := reflect.TypeOf(obj)
-	if len(gvk.Version) == 0 {
-		panic(fmt.Sprintf("version is required on all types: %s %v", gvk, t))
-	}
-	if t.Kind() != reflect.Ptr {
-		panic("All types must be pointers to structs.")
-	}
-	t = t.Elem()
-	if t.Kind() != reflect.Struct {
-		panic("All types must be pointers to structs.")
-	}
-
-	if oldT, found := s.gvkToType[gvk]; found && oldT != t {
-		panic(fmt.Sprintf("Double registration of different types for %v: old=%v.%v, new=%v.%v in scheme %q", gvk, oldT.PkgPath(), oldT.Name(), t.PkgPath(), t.Name(), s.schemeName))
-	}
-
-	s.gvkToType[gvk] = t
-
-	for _, existingGvk := range s.typeToGVK[t] {
-		if existingGvk == gvk {
-			return
-		}
-	}
-	s.typeToGVK[t] = append(s.typeToGVK[t], gvk)
-
-	// if the type implements DeepCopyInto(<obj>), register a self-conversion
-	if m := reflect.ValueOf(obj).MethodByName("DeepCopyInto"); m.IsValid() && m.Type().NumIn() == 1 && m.Type().NumOut() == 0 && m.Type().In(0) == reflect.TypeOf(obj) {
-		if err := s.AddGeneratedConversionFunc(obj, obj, func(a, b interface{}, scope conversion.Scope) error {
-			// copy a to b
-			reflect.ValueOf(a).MethodByName("DeepCopyInto").Call([]reflect.Value{reflect.ValueOf(b)})
-			// clear TypeMeta to match legacy reflective conversion
-			b.(Object).GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{})
-			return nil
-		}); err != nil {
-			panic(err)
-		}
-	}
-}
-
-// KnownTypes returns the types known for the given version.
-func (s *Scheme) KnownTypes(gv schema.GroupVersion) map[string]reflect.Type {
-	types := make(map[string]reflect.Type)
-	for gvk, t := range s.gvkToType {
-		if gv != gvk.GroupVersion() {
-			continue
-		}
-
-		types[gvk.Kind] = t
-	}
-	return types
-}
-
-// VersionsForGroupKind returns the versions that a particular GroupKind can be converted to within the given group.
-// A GroupKind might be converted to a different group. That information is available in EquivalentResourceMapper.
-func (s *Scheme) VersionsForGroupKind(gk schema.GroupKind) []schema.GroupVersion {
-	availableVersions := []schema.GroupVersion{}
-	for gvk := range s.gvkToType {
-		if gk != gvk.GroupKind() {
-			continue
-		}
-
-		availableVersions = append(availableVersions, gvk.GroupVersion())
-	}
-
-	// order the return for stability
-	ret := []schema.GroupVersion{}
-	for _, version := range s.PrioritizedVersionsForGroup(gk.Group) {
-		for _, availableVersion := range availableVersions {
-			if version != availableVersion {
-				continue
-			}
-			ret = append(ret, availableVersion)
-		}
-	}
-
-	return ret
-}
-
-// AllKnownTypes returns the all known types.
-func (s *Scheme) AllKnownTypes() map[schema.GroupVersionKind]reflect.Type {
-	return s.gvkToType
-}
-
-// ObjectKinds returns all possible group,version,kind of the go object, true if the
-// object is considered unversioned, or an error if it's not a pointer or is unregistered.
-func (s *Scheme) ObjectKinds(obj Object) ([]schema.GroupVersionKind, bool, error) {
-	// Unstructured objects are always considered to have their declared GVK
-	if _, ok := obj.(Unstructured); ok {
-		// we require that the GVK be populated in order to recognize the object
-		gvk := obj.GetObjectKind().GroupVersionKind()
-		if len(gvk.Kind) == 0 {
-			return nil, false, NewMissingKindErr("unstructured object has no kind")
-		}
-		if len(gvk.Version) == 0 {
-			return nil, false, NewMissingVersionErr("unstructured object has no version")
-		}
-		return []schema.GroupVersionKind{gvk}, false, nil
-	}
-
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return nil, false, err
-	}
-	t := v.Type()
-
-	gvks, ok := s.typeToGVK[t]
-	if !ok {
-		return nil, false, NewNotRegisteredErrForType(s.schemeName, t)
-	}
-	_, unversionedType := s.unversionedTypes[t]
-
-	return gvks, unversionedType, nil
-}
-
-// Recognizes returns true if the scheme is able to handle the provided group,version,kind
-// of an object.
-func (s *Scheme) Recognizes(gvk schema.GroupVersionKind) bool {
-	_, exists := s.gvkToType[gvk]
-	return exists
-}
-
-func (s *Scheme) IsUnversioned(obj Object) (bool, bool) {
-	v, err := conversion.EnforcePtr(obj)
-	if err != nil {
-		return false, false
-	}
-	t := v.Type()
-
-	if _, ok := s.typeToGVK[t]; !ok {
-		return false, false
-	}
-	_, ok := s.unversionedTypes[t]
-	return ok, true
-}
-
-// New returns a new API object of the given version and name, or an error if it hasn't
-// been registered. The version and kind fields must be specified.
-func (s *Scheme) New(kind schema.GroupVersionKind) (Object, error) {
-	if t, exists := s.gvkToType[kind]; exists {
-		return reflect.New(t).Interface().(Object), nil
-	}
-
-	if t, exists := s.unversionedKinds[kind.Kind]; exists {
-		return reflect.New(t).Interface().(Object), nil
-	}
-	return nil, NewNotRegisteredErrForKind(s.schemeName, kind)
-}
-
-// AddIgnoredConversionType identifies a pair of types that should be skipped by
-// conversion (because the data inside them is explicitly dropped during
-// conversion).
-func (s *Scheme) AddIgnoredConversionType(from, to interface{}) error {
-	return s.converter.RegisterIgnoredConversion(from, to)
-}
-
-// AddConversionFunc registers a function that converts between a and b by passing objects of those
-// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce
-// any other guarantee.
-func (s *Scheme) AddConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error {
-	return s.converter.RegisterUntypedConversionFunc(a, b, fn)
-}
-
-// AddGeneratedConversionFunc registers a function that converts between a and b by passing objects of those
-// types to the provided function. The function *must* accept objects of a and b - this machinery will not enforce
-// any other guarantee.
-func (s *Scheme) AddGeneratedConversionFunc(a, b interface{}, fn conversion.ConversionFunc) error {
-	return s.converter.RegisterGeneratedUntypedConversionFunc(a, b, fn)
-}
-
-// AddFieldLabelConversionFunc adds a conversion function to convert field selectors
-// of the given kind from the given version to internal version representation.
-func (s *Scheme) AddFieldLabelConversionFunc(gvk schema.GroupVersionKind, conversionFunc FieldLabelConversionFunc) error {
-	s.fieldLabelConversionFuncs[gvk] = conversionFunc
-	return nil
-}
-
-// AddTypeDefaultingFunc registers a function that is passed a pointer to an
-// object and can default fields on the object. These functions will be invoked
-// when Default() is called. The function will never be called unless the
-// defaulted object matches srcType. If this function is invoked twice with the
-// same srcType, the fn passed to the later call will be used instead.
-func (s *Scheme) AddTypeDefaultingFunc(srcType Object, fn func(interface{})) {
-	s.defaulterFuncs[reflect.TypeOf(srcType)] = fn
-}
-
-// Default sets defaults on the provided Object.
-func (s *Scheme) Default(src Object) {
-	if fn, ok := s.defaulterFuncs[reflect.TypeOf(src)]; ok {
-		fn(src)
-	}
-}
-
-// Convert will attempt to convert in into out. Both must be pointers. For easy
-// testing of conversion functions. Returns an error if the conversion isn't
-// possible. You can call this with types that haven't been registered (for example,
-// a to test conversion of types that are nested within registered types). The
-// context interface is passed to the convertor. Convert also supports Unstructured
-// types and will convert them intelligently.
-func (s *Scheme) Convert(in, out interface{}, context interface{}) error {
-	unstructuredIn, okIn := in.(Unstructured)
-	unstructuredOut, okOut := out.(Unstructured)
-	switch {
-	case okIn && okOut:
-		// converting unstructured input to an unstructured output is a straight copy - unstructured
-		// is a "smart holder" and the contents are passed by reference between the two objects
-		unstructuredOut.SetUnstructuredContent(unstructuredIn.UnstructuredContent())
-		return nil
-
-	case okOut:
-		// if the output is an unstructured object, use the standard Go type to unstructured
-		// conversion. The object must not be internal.
-		obj, ok := in.(Object)
-		if !ok {
-			return fmt.Errorf("unable to convert object type %T to Unstructured, must be a runtime.Object", in)
-		}
-		gvks, unversioned, err := s.ObjectKinds(obj)
-		if err != nil {
-			return err
-		}
-		gvk := gvks[0]
-
-		// if no conversion is necessary, convert immediately
-		if unversioned || gvk.Version != APIVersionInternal {
-			content, err := DefaultUnstructuredConverter.ToUnstructured(in)
-			if err != nil {
-				return err
-			}
-			unstructuredOut.SetUnstructuredContent(content)
-			unstructuredOut.GetObjectKind().SetGroupVersionKind(gvk)
-			return nil
-		}
-
-		// attempt to convert the object to an external version first.
-		target, ok := context.(GroupVersioner)
-		if !ok {
-			return fmt.Errorf("unable to convert the internal object type %T to Unstructured without providing a preferred version to convert to", in)
-		}
-		// Convert is implicitly unsafe, so we don't need to perform a safe conversion
-		versioned, err := s.UnsafeConvertToVersion(obj, target)
-		if err != nil {
-			return err
-		}
-		content, err := DefaultUnstructuredConverter.ToUnstructured(versioned)
-		if err != nil {
-			return err
-		}
-		unstructuredOut.SetUnstructuredContent(content)
-		return nil
-
-	case okIn:
-		// converting an unstructured object to any type is modeled by first converting
-		// the input to a versioned type, then running standard conversions
-		typed, err := s.unstructuredToTyped(unstructuredIn)
-		if err != nil {
-			return err
-		}
-		in = typed
-	}
-
-	meta := s.generateConvertMeta(in)
-	meta.Context = context
-	return s.converter.Convert(in, out, meta)
-}
-
-// ConvertFieldLabel alters the given field label and value for an kind field selector from
-// versioned representation to an unversioned one or returns an error.
-func (s *Scheme) ConvertFieldLabel(gvk schema.GroupVersionKind, label, value string) (string, string, error) {
-	conversionFunc, ok := s.fieldLabelConversionFuncs[gvk]
-	if !ok {
-		return DefaultMetaV1FieldSelectorConversion(label, value)
-	}
-	return conversionFunc(label, value)
-}
-
-// ConvertToVersion attempts to convert an input object to its matching Kind in another
-// version within this scheme. Will return an error if the provided version does not
-// contain the inKind (or a mapping by name defined with AddKnownTypeWithName). Will also
-// return an error if the conversion does not result in a valid Object being
-// returned. Passes target down to the conversion methods as the Context on the scope.
-func (s *Scheme) ConvertToVersion(in Object, target GroupVersioner) (Object, error) {
-	return s.convertToVersion(true, in, target)
-}
-
-// UnsafeConvertToVersion will convert in to the provided target if such a conversion is possible,
-// but does not guarantee the output object does not share fields with the input object. It attempts to be as
-// efficient as possible when doing conversion.
-func (s *Scheme) UnsafeConvertToVersion(in Object, target GroupVersioner) (Object, error) {
-	return s.convertToVersion(false, in, target)
-}
-
-// convertToVersion handles conversion with an optional copy.
-func (s *Scheme) convertToVersion(copy bool, in Object, target GroupVersioner) (Object, error) {
-	var t reflect.Type
-
-	if u, ok := in.(Unstructured); ok {
-		typed, err := s.unstructuredToTyped(u)
-		if err != nil {
-			return nil, err
-		}
-
-		in = typed
-		// unstructuredToTyped returns an Object, which must be a pointer to a struct.
-		t = reflect.TypeOf(in).Elem()
-
-	} else {
-		// determine the incoming kinds with as few allocations as possible.
-		t = reflect.TypeOf(in)
-		if t.Kind() != reflect.Ptr {
-			return nil, fmt.Errorf("only pointer types may be converted: %v", t)
-		}
-		t = t.Elem()
-		if t.Kind() != reflect.Struct {
-			return nil, fmt.Errorf("only pointers to struct types may be converted: %v", t)
-		}
-	}
-
-	kinds, ok := s.typeToGVK[t]
-	if !ok || len(kinds) == 0 {
-		return nil, NewNotRegisteredErrForType(s.schemeName, t)
-	}
-
-	gvk, ok := target.KindForGroupVersionKinds(kinds)
-	if !ok {
-		// try to see if this type is listed as unversioned (for legacy support)
-		// TODO: when we move to server API versions, we should completely remove the unversioned concept
-		if unversionedKind, ok := s.unversionedTypes[t]; ok {
-			if gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{unversionedKind}); ok {
-				return copyAndSetTargetKind(copy, in, gvk)
-			}
-			return copyAndSetTargetKind(copy, in, unversionedKind)
-		}
-		return nil, NewNotRegisteredErrForTarget(s.schemeName, t, target)
-	}
-
-	// target wants to use the existing type, set kind and return (no conversion necessary)
-	for _, kind := range kinds {
-		if gvk == kind {
-			return copyAndSetTargetKind(copy, in, gvk)
-		}
-	}
-
-	// type is unversioned, no conversion necessary
-	if unversionedKind, ok := s.unversionedTypes[t]; ok {
-		if gvk, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{unversionedKind}); ok {
-			return copyAndSetTargetKind(copy, in, gvk)
-		}
-		return copyAndSetTargetKind(copy, in, unversionedKind)
-	}
-
-	out, err := s.New(gvk)
-	if err != nil {
-		return nil, err
-	}
-
-	if copy {
-		in = in.DeepCopyObject()
-	}
-
-	meta := s.generateConvertMeta(in)
-	meta.Context = target
-	if err := s.converter.Convert(in, out, meta); err != nil {
-		return nil, err
-	}
-
-	setTargetKind(out, gvk)
-	return out, nil
-}
-
-// unstructuredToTyped attempts to transform an unstructured object to a typed
-// object if possible. It will return an error if conversion is not possible, or the versioned
-// Go form of the object. Note that this conversion will lose fields.
-func (s *Scheme) unstructuredToTyped(in Unstructured) (Object, error) {
-	// the type must be something we recognize
-	gvks, _, err := s.ObjectKinds(in)
-	if err != nil {
-		return nil, err
-	}
-	typed, err := s.New(gvks[0])
-	if err != nil {
-		return nil, err
-	}
-	if err := DefaultUnstructuredConverter.FromUnstructured(in.UnstructuredContent(), typed); err != nil {
-		return nil, fmt.Errorf("unable to convert unstructured object to %v: %v", gvks[0], err)
-	}
-	return typed, nil
-}
-
-// generateConvertMeta constructs the meta value we pass to Convert.
-func (s *Scheme) generateConvertMeta(in interface{}) *conversion.Meta {
-	return s.converter.DefaultMeta(reflect.TypeOf(in))
-}
-
-// copyAndSetTargetKind performs a conditional copy before returning the object, or an error if copy was not successful.
-func copyAndSetTargetKind(copy bool, obj Object, kind schema.GroupVersionKind) (Object, error) {
-	if copy {
-		obj = obj.DeepCopyObject()
-	}
-	setTargetKind(obj, kind)
-	return obj, nil
-}
-
-// setTargetKind sets the kind on an object, taking into account whether the target kind is the internal version.
-func setTargetKind(obj Object, kind schema.GroupVersionKind) {
-	if kind.Version == APIVersionInternal {
-		// internal is a special case
-		// TODO: look at removing the need to special case this
-		obj.GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{})
-		return
-	}
-	obj.GetObjectKind().SetGroupVersionKind(kind)
-}
-
-// SetVersionPriority allows specifying a precise order of priority. All specified versions must be in the same group,
-// and the specified order overwrites any previously specified order for this group
-func (s *Scheme) SetVersionPriority(versions ...schema.GroupVersion) error {
-	groups := sets.String{}
-	order := []string{}
-	for _, version := range versions {
-		if len(version.Version) == 0 || version.Version == APIVersionInternal {
-			return fmt.Errorf("internal versions cannot be prioritized: %v", version)
-		}
-
-		groups.Insert(version.Group)
-		order = append(order, version.Version)
-	}
-	if len(groups) != 1 {
-		return fmt.Errorf("must register versions for exactly one group: %v", strings.Join(groups.List(), ", "))
-	}
-
-	s.versionPriority[groups.List()[0]] = order
-	return nil
-}
-
-// PrioritizedVersionsForGroup returns versions for a single group in priority order
-func (s *Scheme) PrioritizedVersionsForGroup(group string) []schema.GroupVersion {
-	ret := []schema.GroupVersion{}
-	for _, version := range s.versionPriority[group] {
-		ret = append(ret, schema.GroupVersion{Group: group, Version: version})
-	}
-	for _, observedVersion := range s.observedVersions {
-		if observedVersion.Group != group {
-			continue
-		}
-		found := false
-		for _, existing := range ret {
-			if existing == observedVersion {
-				found = true
-				break
-			}
-		}
-		if !found {
-			ret = append(ret, observedVersion)
-		}
-	}
-
-	return ret
-}
-
-// PrioritizedVersionsAllGroups returns all known versions in their priority order.  Groups are random, but
-// versions for a single group are prioritized
-func (s *Scheme) PrioritizedVersionsAllGroups() []schema.GroupVersion {
-	ret := []schema.GroupVersion{}
-	for group, versions := range s.versionPriority {
-		for _, version := range versions {
-			ret = append(ret, schema.GroupVersion{Group: group, Version: version})
-		}
-	}
-	for _, observedVersion := range s.observedVersions {
-		found := false
-		for _, existing := range ret {
-			if existing == observedVersion {
-				found = true
-				break
-			}
-		}
-		if !found {
-			ret = append(ret, observedVersion)
-		}
-	}
-	return ret
-}
-
-// PreferredVersionAllGroups returns the most preferred version for every group.
-// group ordering is random.
-func (s *Scheme) PreferredVersionAllGroups() []schema.GroupVersion {
-	ret := []schema.GroupVersion{}
-	for group, versions := range s.versionPriority {
-		for _, version := range versions {
-			ret = append(ret, schema.GroupVersion{Group: group, Version: version})
-			break
-		}
-	}
-	for _, observedVersion := range s.observedVersions {
-		found := false
-		for _, existing := range ret {
-			if existing.Group == observedVersion.Group {
-				found = true
-				break
-			}
-		}
-		if !found {
-			ret = append(ret, observedVersion)
-		}
-	}
-
-	return ret
-}
-
-// IsGroupRegistered returns true if types for the group have been registered with the scheme
-func (s *Scheme) IsGroupRegistered(group string) bool {
-	for _, observedVersion := range s.observedVersions {
-		if observedVersion.Group == group {
-			return true
-		}
-	}
-	return false
-}
-
-// IsVersionRegistered returns true if types for the version have been registered with the scheme
-func (s *Scheme) IsVersionRegistered(version schema.GroupVersion) bool {
-	for _, observedVersion := range s.observedVersions {
-		if observedVersion == version {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (s *Scheme) addObservedVersion(version schema.GroupVersion) {
-	if len(version.Version) == 0 || version.Version == APIVersionInternal {
-		return
-	}
-	for _, observedVersion := range s.observedVersions {
-		if observedVersion == version {
-			return
-		}
-	}
-
-	s.observedVersions = append(s.observedVersions, version)
-}
-
-func (s *Scheme) Name() string {
-	return s.schemeName
-}
-
-// internalPackages are packages that ignored when creating a default reflector name. These packages are in the common
-// call chains to NewReflector, so they'd be low entropy names for reflectors
-var internalPackages = []string{"k8s.io/apimachinery/pkg/runtime/scheme.go"}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go b/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go
deleted file mode 100644
index 944db4818..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/scheme_builder.go
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-Copyright 2015 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 runtime
-
-// SchemeBuilder collects functions that add things to a scheme. It's to allow
-// code to compile without explicitly referencing generated types. You should
-// declare one in each package that will have generated deep copy or conversion
-// functions.
-type SchemeBuilder []func(*Scheme) error
-
-// AddToScheme applies all the stored functions to the scheme. A non-nil error
-// indicates that one function failed and the attempt was abandoned.
-func (sb *SchemeBuilder) AddToScheme(s *Scheme) error {
-	for _, f := range *sb {
-		if err := f(s); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Register adds a scheme setup function to the list.
-func (sb *SchemeBuilder) Register(funcs ...func(*Scheme) error) {
-	for _, f := range funcs {
-		*sb = append(*sb, f)
-	}
-}
-
-// NewSchemeBuilder calls Register for you.
-func NewSchemeBuilder(funcs ...func(*Scheme) error) SchemeBuilder {
-	var sb SchemeBuilder
-	sb.Register(funcs...)
-	return sb
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go b/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go
deleted file mode 100644
index 5bc642bc8..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/swagger_doc_generator.go
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
-Copyright 2015 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 runtime
-
-import (
-	"bytes"
-	"fmt"
-	"go/ast"
-	"go/doc"
-	"go/parser"
-	"go/token"
-	"io"
-	"reflect"
-	"strings"
-)
-
-// Pair of strings. We keed the name of fields and the doc
-type Pair struct {
-	Name, Doc string
-}
-
-// KubeTypes is an array to represent all available types in a parsed file. [0] is for the type itself
-type KubeTypes []Pair
-
-func astFrom(filePath string) *doc.Package {
-	fset := token.NewFileSet()
-	m := make(map[string]*ast.File)
-
-	f, err := parser.ParseFile(fset, filePath, nil, parser.ParseComments)
-	if err != nil {
-		fmt.Println(err)
-		return nil
-	}
-
-	m[filePath] = f
-	apkg, _ := ast.NewPackage(fset, m, nil, nil)
-
-	return doc.New(apkg, "", 0)
-}
-
-func fmtRawDoc(rawDoc string) string {
-	var buffer bytes.Buffer
-	delPrevChar := func() {
-		if buffer.Len() > 0 {
-			buffer.Truncate(buffer.Len() - 1) // Delete the last " " or "\n"
-		}
-	}
-
-	// Ignore all lines after ---
-	rawDoc = strings.Split(rawDoc, "---")[0]
-
-	for _, line := range strings.Split(rawDoc, "\n") {
-		line = strings.TrimRight(line, " ")
-		leading := strings.TrimLeft(line, " ")
-		switch {
-		case len(line) == 0: // Keep paragraphs
-			delPrevChar()
-			buffer.WriteString("\n\n")
-		case strings.HasPrefix(leading, "TODO"): // Ignore one line TODOs
-		case strings.HasPrefix(leading, "+"): // Ignore instructions to the generators
-		default:
-			if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") {
-				delPrevChar()
-				line = "\n" + line + "\n" // Replace it with newline. This is useful when we have a line with: "Example:\n\tJSON-someting..."
-			} else {
-				line += " "
-			}
-			buffer.WriteString(line)
-		}
-	}
-
-	postDoc := strings.TrimRight(buffer.String(), "\n")
-	postDoc = strings.Replace(postDoc, "\\\"", "\"", -1) // replace user's \" to "
-	postDoc = strings.Replace(postDoc, "\"", "\\\"", -1) // Escape "
-	postDoc = strings.Replace(postDoc, "\n", "\\n", -1)
-	postDoc = strings.Replace(postDoc, "\t", "\\t", -1)
-
-	return postDoc
-}
-
-// fieldName returns the name of the field as it should appear in JSON format
-// "-" indicates that this field is not part of the JSON representation
-func fieldName(field *ast.Field) string {
-	jsonTag := ""
-	if field.Tag != nil {
-		jsonTag = reflect.StructTag(field.Tag.Value[1 : len(field.Tag.Value)-1]).Get("json") // Delete first and last quotation
-		if strings.Contains(jsonTag, "inline") {
-			return "-"
-		}
-	}
-
-	jsonTag = strings.Split(jsonTag, ",")[0] // This can return "-"
-	if jsonTag == "" {
-		if field.Names != nil {
-			return field.Names[0].Name
-		}
-		return field.Type.(*ast.Ident).Name
-	}
-	return jsonTag
-}
-
-// A buffer of lines that will be written.
-type bufferedLine struct {
-	line        string
-	indentation int
-}
-
-type buffer struct {
-	lines []bufferedLine
-}
-
-func newBuffer() *buffer {
-	return &buffer{
-		lines: make([]bufferedLine, 0),
-	}
-}
-
-func (b *buffer) addLine(line string, indent int) {
-	b.lines = append(b.lines, bufferedLine{line, indent})
-}
-
-func (b *buffer) flushLines(w io.Writer) error {
-	for _, line := range b.lines {
-		indentation := strings.Repeat("\t", line.indentation)
-		fullLine := fmt.Sprintf("%s%s", indentation, line.line)
-		if _, err := io.WriteString(w, fullLine); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeFuncHeader(b *buffer, structName string, indent int) {
-	s := fmt.Sprintf("var map_%s = map[string]string {\n", structName)
-	b.addLine(s, indent)
-}
-
-func writeFuncFooter(b *buffer, structName string, indent int) {
-	b.addLine("}\n", indent) // Closes the map definition
-
-	s := fmt.Sprintf("func (%s) SwaggerDoc() map[string]string {\n", structName)
-	b.addLine(s, indent)
-	s = fmt.Sprintf("return map_%s\n", structName)
-	b.addLine(s, indent+1)
-	b.addLine("}\n", indent) // Closes the function definition
-}
-
-func writeMapBody(b *buffer, kubeType []Pair, indent int) {
-	format := "\"%s\": \"%s\",\n"
-	for _, pair := range kubeType {
-		s := fmt.Sprintf(format, pair.Name, pair.Doc)
-		b.addLine(s, indent+2)
-	}
-}
-
-// ParseDocumentationFrom gets all types' documentation and returns them as an
-// array. Each type is again represented as an array (we have to use arrays as we
-// need to be sure for the order of the fields). This function returns fields and
-// struct definitions that have no documentation as {name, ""}.
-func ParseDocumentationFrom(src string) []KubeTypes {
-	var docForTypes []KubeTypes
-
-	pkg := astFrom(src)
-
-	for _, kubType := range pkg.Types {
-		if structType, ok := kubType.Decl.Specs[0].(*ast.TypeSpec).Type.(*ast.StructType); ok {
-			var ks KubeTypes
-			ks = append(ks, Pair{kubType.Name, fmtRawDoc(kubType.Doc)})
-
-			for _, field := range structType.Fields.List {
-				if n := fieldName(field); n != "-" {
-					fieldDoc := fmtRawDoc(field.Doc.Text())
-					ks = append(ks, Pair{n, fieldDoc})
-				}
-			}
-			docForTypes = append(docForTypes, ks)
-		}
-	}
-
-	return docForTypes
-}
-
-// WriteSwaggerDocFunc writes a declaration of a function as a string. This function is used in
-// Swagger as a documentation source for structs and theirs fields
-func WriteSwaggerDocFunc(kubeTypes []KubeTypes, w io.Writer) error {
-	for _, kubeType := range kubeTypes {
-		structName := kubeType[0].Name
-		kubeType[0].Name = ""
-
-		// Ignore empty documentation
-		docfulTypes := make(KubeTypes, 0, len(kubeType))
-		for _, pair := range kubeType {
-			if pair.Doc != "" {
-				docfulTypes = append(docfulTypes, pair)
-			}
-		}
-
-		if len(docfulTypes) == 0 {
-			continue // If no fields and the struct have documentation, skip the function definition
-		}
-
-		indent := 0
-		buffer := newBuffer()
-
-		writeFuncHeader(buffer, structName, indent)
-		writeMapBody(buffer, docfulTypes, indent)
-		writeFuncFooter(buffer, structName, indent)
-		buffer.addLine("\n", 0)
-
-		if err := buffer.flushLines(w); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// VerifySwaggerDocsExist writes in a io.Writer a list of structs and fields that
-// are missing of documentation.
-func VerifySwaggerDocsExist(kubeTypes []KubeTypes, w io.Writer) (int, error) {
-	missingDocs := 0
-	buffer := newBuffer()
-
-	for _, kubeType := range kubeTypes {
-		structName := kubeType[0].Name
-		if kubeType[0].Doc == "" {
-			format := "Missing documentation for the struct itself: %s\n"
-			s := fmt.Sprintf(format, structName)
-			buffer.addLine(s, 0)
-			missingDocs++
-		}
-		kubeType = kubeType[1:] // Skip struct definition
-
-		for _, pair := range kubeType { // Iterate only the fields
-			if pair.Doc == "" {
-				format := "In struct: %s, field documentation is missing: %s\n"
-				s := fmt.Sprintf(format, structName, pair.Name)
-				buffer.addLine(s, 0)
-				missingDocs++
-			}
-		}
-	}
-
-	if err := buffer.flushLines(w); err != nil {
-		return -1, err
-	}
-	return missingDocs, nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/types.go b/vendor/k8s.io/apimachinery/pkg/runtime/types.go
deleted file mode 100644
index 31359f35f..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/types.go
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-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.
-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 runtime
-
-// Note that the types provided in this file are not versioned and are intended to be
-// safe to use from within all versions of every API object.
-
-// TypeMeta is shared by all top level objects. The proper way to use it is to inline it in your type,
-// like this:
-// type MyAwesomeAPIObject struct {
-//      runtime.TypeMeta    `json:",inline"`
-//      ... // other fields
-// }
-// func (obj *MyAwesomeAPIObject) SetGroupVersionKind(gvk *metav1.GroupVersionKind) { metav1.UpdateTypeMeta(obj,gvk) }; GroupVersionKind() *GroupVersionKind
-//
-// TypeMeta is provided here for convenience. You may use it directly from this package or define
-// your own with the same fields.
-//
-// +k8s:deepcopy-gen=false
-// +protobuf=true
-// +k8s:openapi-gen=true
-type TypeMeta struct {
-	// +optional
-	APIVersion string `json:"apiVersion,omitempty" yaml:"apiVersion,omitempty" protobuf:"bytes,1,opt,name=apiVersion"`
-	// +optional
-	Kind string `json:"kind,omitempty" yaml:"kind,omitempty" protobuf:"bytes,2,opt,name=kind"`
-}
-
-const (
-	ContentTypeJSON     string = "application/json"
-	ContentTypeYAML     string = "application/yaml"
-	ContentTypeProtobuf string = "application/vnd.kubernetes.protobuf"
-)
-
-// RawExtension is used to hold extensions in external versions.
-//
-// To use this, make a field which has RawExtension as its type in your external, versioned
-// struct, and Object in your internal struct. You also need to register your
-// various plugin types.
-//
-// // Internal package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-//	MyPlugin runtime.Object `json:"myPlugin"`
-// }
-// type PluginA struct {
-//	AOption string `json:"aOption"`
-// }
-//
-// // External package:
-// type MyAPIObject struct {
-// 	runtime.TypeMeta `json:",inline"`
-//	MyPlugin runtime.RawExtension `json:"myPlugin"`
-// }
-// type PluginA struct {
-//	AOption string `json:"aOption"`
-// }
-//
-// // On the wire, the JSON will look something like this:
-// {
-//	"kind":"MyAPIObject",
-//	"apiVersion":"v1",
-//	"myPlugin": {
-//		"kind":"PluginA",
-//		"aOption":"foo",
-//	},
-// }
-//
-// So what happens? Decode first uses json or yaml to unmarshal the serialized data into
-// your external MyAPIObject. That causes the raw JSON to be stored, but not unpacked.
-// The next step is to copy (using pkg/conversion) into the internal struct. The runtime
-// package's DefaultScheme has conversion functions installed which will unpack the
-// JSON stored in RawExtension, turning it into the correct object type, and storing it
-// in the Object. (TODO: In the case where the object is of an unknown type, a
-// runtime.Unknown object will be created and stored.)
-//
-// +k8s:deepcopy-gen=true
-// +protobuf=true
-// +k8s:openapi-gen=true
-type RawExtension struct {
-	// Raw is the underlying serialization of this object.
-	//
-	// TODO: Determine how to detect ContentType and ContentEncoding of 'Raw' data.
-	Raw []byte `json:"-" protobuf:"bytes,1,opt,name=raw"`
-	// Object can hold a representation of this extension - useful for working with versioned
-	// structs.
-	Object Object `json:"-"`
-}
-
-// Unknown allows api objects with unknown types to be passed-through. This can be used
-// to deal with the API objects from a plug-in. Unknown objects still have functioning
-// TypeMeta features-- kind, version, etc.
-// TODO: Make this object have easy access to field based accessors and settors for
-// metadata and field mutatation.
-//
-// +k8s:deepcopy-gen=true
-// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
-// +protobuf=true
-// +k8s:openapi-gen=true
-type Unknown struct {
-	TypeMeta `json:",inline" protobuf:"bytes,1,opt,name=typeMeta"`
-	// Raw will hold the complete serialized object which couldn't be matched
-	// with a registered type. Most likely, nothing should be done with this
-	// except for passing it through the system.
-	Raw []byte `protobuf:"bytes,2,opt,name=raw"`
-	// ContentEncoding is encoding used to encode 'Raw' data.
-	// Unspecified means no encoding.
-	ContentEncoding string `protobuf:"bytes,3,opt,name=contentEncoding"`
-	// ContentType  is serialization method used to serialize 'Raw'.
-	// Unspecified means ContentTypeJSON.
-	ContentType string `protobuf:"bytes,4,opt,name=contentType"`
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go b/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go
deleted file mode 100644
index a82227b23..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/types_proto.go
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
-Copyright 2015 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 runtime
-
-import (
-	"fmt"
-)
-
-type ProtobufMarshaller interface {
-	MarshalTo(data []byte) (int, error)
-}
-
-type ProtobufReverseMarshaller interface {
-	MarshalToSizedBuffer(data []byte) (int, error)
-}
-
-// NestedMarshalTo allows a caller to avoid extra allocations during serialization of an Unknown
-// that will contain an object that implements ProtobufMarshaller or ProtobufReverseMarshaller.
-func (m *Unknown) NestedMarshalTo(data []byte, b ProtobufMarshaller, size uint64) (int, error) {
-	// Calculate the full size of the message.
-	msgSize := m.Size()
-	if b != nil {
-		msgSize += int(size) + sovGenerated(size) + 1
-	}
-
-	// Reverse marshal the fields of m.
-	i := msgSize
-	i -= len(m.ContentType)
-	copy(data[i:], m.ContentType)
-	i = encodeVarintGenerated(data, i, uint64(len(m.ContentType)))
-	i--
-	data[i] = 0x22
-	i -= len(m.ContentEncoding)
-	copy(data[i:], m.ContentEncoding)
-	i = encodeVarintGenerated(data, i, uint64(len(m.ContentEncoding)))
-	i--
-	data[i] = 0x1a
-	if b != nil {
-		if r, ok := b.(ProtobufReverseMarshaller); ok {
-			n1, err := r.MarshalToSizedBuffer(data[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= int(size)
-			if uint64(n1) != size {
-				// programmer error: the Size() method for protobuf does not match the results of LashramOt, which means the proto
-				// struct returned would be wrong.
-				return 0, fmt.Errorf("the Size() value of %T was %d, but NestedMarshalTo wrote %d bytes to data", b, size, n1)
-			}
-		} else {
-			i -= int(size)
-			n1, err := b.MarshalTo(data[i:])
-			if err != nil {
-				return 0, err
-			}
-			if uint64(n1) != size {
-				// programmer error: the Size() method for protobuf does not match the results of MarshalTo, which means the proto
-				// struct returned would be wrong.
-				return 0, fmt.Errorf("the Size() value of %T was %d, but NestedMarshalTo wrote %d bytes to data", b, size, n1)
-			}
-		}
-		i = encodeVarintGenerated(data, i, size)
-		i--
-		data[i] = 0x12
-	}
-	n2, err := m.TypeMeta.MarshalToSizedBuffer(data[:i])
-	if err != nil {
-		return 0, err
-	}
-	i -= n2
-	i = encodeVarintGenerated(data, i, uint64(n2))
-	i--
-	data[i] = 0xa
-	return msgSize - i, nil
-}
diff --git a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go b/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go
deleted file mode 100644
index b0393839e..000000000
--- a/vendor/k8s.io/apimachinery/pkg/runtime/zz_generated.deepcopy.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// +build !ignore_autogenerated
-
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by deepcopy-gen. DO NOT EDIT.
-
-package runtime
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RawExtension) DeepCopyInto(out *RawExtension) {
-	*out = *in
-	if in.Raw != nil {
-		in, out := &in.Raw, &out.Raw
-		*out = make([]byte, len(*in))
-		copy(*out, *in)
-	}
-	if in.Object != nil {
-		out.Object = in.Object.DeepCopyObject()
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RawExtension.
-func (in *RawExtension) DeepCopy() *RawExtension {
-	if in == nil {
-		return nil
-	}
-	out := new(RawExtension)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Unknown) DeepCopyInto(out *Unknown) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	if in.Raw != nil {
-		in, out := &in.Raw, &out.Raw
-		*out = make([]byte, len(*in))
-		copy(*out, *in)
-	}
-	return
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Unknown.
-func (in *Unknown) DeepCopy() *Unknown {
-	if in == nil {
-		return nil
-	}
-	out := new(Unknown)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new Object.
-func (in *Unknown) DeepCopyObject() Object {
-	if c := in.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}