rebase: update kubernetes dep to 1.24.0

As kubernetes 1.24.0 is released, updating
kubernetes dependencies to 1.24.0

updates: #3086

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/k8s.io/kube-openapi/pkg/builder3/util/util.go

@@ -0,0 +1,51 @@
+/*
+Copyright 2022 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 util
+
+import (
+	"reflect"
+
+	"k8s.io/kube-openapi/pkg/schemamutation"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// wrapRefs wraps OpenAPI V3 Schema refs that contain sibling elements.
+// AllOf is used to wrap the Ref to prevent references from having sibling elements
+// Please see https://github.com/kubernetes/kubernetes/issues/106387#issuecomment-967640388
+func WrapRefs(schema *spec.Schema) *spec.Schema {
+	walker := schemamutation.Walker{
+		SchemaCallback: func(schema *spec.Schema) *spec.Schema {
+			orig := schema
+			clone := func() {
+				if orig == schema {
+					schema = new(spec.Schema)
+					*schema = *orig
+				}
+			}
+			if schema.Ref.String() != "" && !reflect.DeepEqual(*schema, spec.Schema{SchemaProps: spec.SchemaProps{Ref: schema.Ref}}) {
+				clone()
+				refSchema := new(spec.Schema)
+				refSchema.Ref = schema.Ref
+				schema.Ref = spec.Ref{}
+				schema.AllOf = []spec.Schema{*refSchema}
+			}
+			return schema
+		},
+		RefCallback: schemamutation.RefCallbackNoop,
+	}
+	return walker.WalkSchema(schema)
+}

vendor/k8s.io/kube-openapi/pkg/common/common.go

@@ -0,0 +1,320 @@
+/*
+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 common
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/emicklei/go-restful"
+
+	"k8s.io/kube-openapi/pkg/openapiconv"
+	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+const (
+	// TODO: Make this configurable.
+	ExtensionPrefix   = "x-kubernetes-"
+	ExtensionV2Schema = ExtensionPrefix + "v2-schema"
+)
+
+// OpenAPIDefinition describes single type. Normally these definitions are auto-generated using gen-openapi.
+type OpenAPIDefinition struct {
+	Schema       spec.Schema
+	Dependencies []string
+}
+
+type ReferenceCallback func(path string) spec.Ref
+
+// GetOpenAPIDefinitions is collection of all definitions.
+type GetOpenAPIDefinitions func(ReferenceCallback) map[string]OpenAPIDefinition
+
+// OpenAPIDefinitionGetter gets openAPI definitions for a given type. If a type implements this interface,
+// the definition returned by it will be used, otherwise the auto-generated definitions will be used. See
+// GetOpenAPITypeFormat for more information about trade-offs of using this interface or GetOpenAPITypeFormat method when
+// possible.
+type OpenAPIDefinitionGetter interface {
+	OpenAPIDefinition() *OpenAPIDefinition
+}
+
+type OpenAPIV3DefinitionGetter interface {
+	OpenAPIV3Definition() *OpenAPIDefinition
+}
+
+type PathHandler interface {
+	Handle(path string, handler http.Handler)
+}
+
+type PathHandlerByGroupVersion interface {
+	Handle(path string, handler http.Handler)
+	HandlePrefix(path string, handler http.Handler)
+}
+
+// Config is set of configuration for openAPI spec generation.
+type Config struct {
+	// List of supported protocols such as https, http, etc.
+	ProtocolList []string
+
+	// Info is general information about the API.
+	Info *spec.Info
+
+	// DefaultResponse will be used if an operation does not have any responses listed. It
+	// will show up as ... "responses" : {"default" : $DefaultResponse} in the spec.
+	DefaultResponse *spec.Response
+
+	// ResponseDefinitions will be added to "responses" under the top-level swagger object. This is an object
+	// that holds responses definitions that can be used across operations. This property does not define
+	// global responses for all operations. For more info please refer:
+	//     https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#fixed-fields
+	ResponseDefinitions map[string]spec.Response
+
+	// CommonResponses will be added as a response to all operation specs. This is a good place to add common
+	// responses such as authorization failed.
+	CommonResponses map[int]spec.Response
+
+	// List of webservice's path prefixes to ignore
+	IgnorePrefixes []string
+
+	// OpenAPIDefinitions should provide definition for all models used by routes. Failure to provide this map
+	// or any of the models will result in spec generation failure.
+	GetDefinitions GetOpenAPIDefinitions
+
+	// Provides the definition for all models used by routes. One of GetDefinitions or Definitions must be defined to generate a spec.
+	// This takes precedent over the GetDefinitions function
+	Definitions map[string]OpenAPIDefinition
+
+	// GetOperationIDAndTags returns operation id and tags for a restful route. It is an optional function to customize operation IDs.
+	//
+	// Deprecated: GetOperationIDAndTagsFromRoute should be used instead. This cannot be specified if using the new Route
+	// interface set of funcs.
+	GetOperationIDAndTags func(r *restful.Route) (string, []string, error)
+
+	// GetOperationIDAndTagsFromRoute returns operation id and tags for a Route. It is an optional function to customize operation IDs.
+	GetOperationIDAndTagsFromRoute func(r Route) (string, []string, error)
+
+	// GetDefinitionName returns a friendly name for a definition base on the serving path. parameter `name` is the full name of the definition.
+	// It is an optional function to customize model names.
+	GetDefinitionName func(name string) (string, spec.Extensions)
+
+	// PostProcessSpec runs after the spec is ready to serve. It allows a final modification to the spec before serving.
+	PostProcessSpec func(*spec.Swagger) (*spec.Swagger, error)
+
+	// SecurityDefinitions is list of all security definitions for OpenAPI service. If this is not nil, the user of config
+	// is responsible to provide DefaultSecurity and (maybe) add unauthorized response to CommonResponses.
+	SecurityDefinitions *spec.SecurityDefinitions
+
+	// DefaultSecurity for all operations. This will pass as spec.SwaggerProps.Security to OpenAPI.
+	// For most cases, this will be list of acceptable definitions in SecurityDefinitions.
+	DefaultSecurity []map[string][]string
+}
+
+// OpenAPIV3Config is set of configuration for OpenAPI V3 spec generation.
+type OpenAPIV3Config struct {
+	// Info is general information about the API.
+	Info *spec.Info
+
+	// DefaultResponse will be used if an operation does not have any responses listed. It
+	// will show up as ... "responses" : {"default" : $DefaultResponse} in the spec.
+	DefaultResponse *spec3.Response
+
+	// ResponseDefinitions will be added to responses component. This is an object
+	// that holds responses that can be used across operations.
+	ResponseDefinitions map[string]*spec3.Response
+
+	// CommonResponses will be added as a response to all operation specs. This is a good place to add common
+	// responses such as authorization failed.
+	CommonResponses map[int]*spec3.Response
+
+	// List of webservice's path prefixes to ignore
+	IgnorePrefixes []string
+
+	// OpenAPIDefinitions should provide definition for all models used by routes. Failure to provide this map
+	// or any of the models will result in spec generation failure.
+	// One of GetDefinitions or Definitions must be defined to generate a spec.
+	GetDefinitions GetOpenAPIDefinitions
+
+	// Provides the definition for all models used by routes. One of GetDefinitions or Definitions must be defined to generate a spec.
+	// This takes precedent over the GetDefinitions function
+	Definitions map[string]OpenAPIDefinition
+
+	// GetOperationIDAndTags returns operation id and tags for a restful route. It is an optional function to customize operation IDs.
+	//
+	// Deprecated: GetOperationIDAndTagsFromRoute should be used instead. This cannot be specified if using the new Route
+	// interface set of funcs.
+	GetOperationIDAndTags func(r *restful.Route) (string, []string, error)
+
+	// GetOperationIDAndTagsFromRoute returns operation id and tags for a Route. It is an optional function to customize operation IDs.
+	GetOperationIDAndTagsFromRoute func(r Route) (string, []string, error)
+
+	// GetDefinitionName returns a friendly name for a definition base on the serving path. parameter `name` is the full name of the definition.
+	// It is an optional function to customize model names.
+	GetDefinitionName func(name string) (string, spec.Extensions)
+
+	// SecuritySchemes is list of all security schemes for OpenAPI service.
+	SecuritySchemes spec3.SecuritySchemes
+
+	// DefaultSecurity for all operations.
+	DefaultSecurity []map[string][]string
+}
+
+// ConvertConfigToV3 converts a Config object to an OpenAPIV3Config object
+func ConvertConfigToV3(config *Config) *OpenAPIV3Config {
+	if config == nil {
+		return nil
+	}
+
+	v3Config := &OpenAPIV3Config{
+		Info:                           config.Info,
+		IgnorePrefixes:                 config.IgnorePrefixes,
+		GetDefinitions:                 config.GetDefinitions,
+		GetOperationIDAndTags:          config.GetOperationIDAndTags,
+		GetOperationIDAndTagsFromRoute: config.GetOperationIDAndTagsFromRoute,
+		GetDefinitionName:              config.GetDefinitionName,
+		Definitions:                    config.Definitions,
+		SecuritySchemes:                make(spec3.SecuritySchemes),
+		DefaultSecurity:                config.DefaultSecurity,
+		DefaultResponse:                openapiconv.ConvertResponse(config.DefaultResponse, []string{"application/json"}),
+
+		CommonResponses:     make(map[int]*spec3.Response),
+		ResponseDefinitions: make(map[string]*spec3.Response),
+	}
+
+	if config.SecurityDefinitions != nil {
+		for s, securityScheme := range *config.SecurityDefinitions {
+			v3Config.SecuritySchemes[s] = openapiconv.ConvertSecurityScheme(securityScheme)
+		}
+	}
+	for k, commonResponse := range config.CommonResponses {
+		v3Config.CommonResponses[k] = openapiconv.ConvertResponse(&commonResponse, []string{"application/json"})
+	}
+
+	for k, responseDefinition := range config.ResponseDefinitions {
+		v3Config.ResponseDefinitions[k] = openapiconv.ConvertResponse(&responseDefinition, []string{"application/json"})
+	}
+	return v3Config
+}
+
+type typeInfo struct {
+	name   string
+	format string
+	zero   interface{}
+}
+
+var schemaTypeFormatMap = map[string]typeInfo{
+	"uint":        {"integer", "int32", 0.},
+	"uint8":       {"integer", "byte", 0.},
+	"uint16":      {"integer", "int32", 0.},
+	"uint32":      {"integer", "int64", 0.},
+	"uint64":      {"integer", "int64", 0.},
+	"int":         {"integer", "int32", 0.},
+	"int8":        {"integer", "byte", 0.},
+	"int16":       {"integer", "int32", 0.},
+	"int32":       {"integer", "int32", 0.},
+	"int64":       {"integer", "int64", 0.},
+	"byte":        {"integer", "byte", 0},
+	"float64":     {"number", "double", 0.},
+	"float32":     {"number", "float", 0.},
+	"bool":        {"boolean", "", false},
+	"time.Time":   {"string", "date-time", ""},
+	"string":      {"string", "", ""},
+	"integer":     {"integer", "", 0.},
+	"number":      {"number", "", 0.},
+	"boolean":     {"boolean", "", false},
+	"[]byte":      {"string", "byte", ""}, // base64 encoded characters
+	"interface{}": {"object", "", interface{}(nil)},
+}
+
+// This function is a reference for converting go (or any custom type) to a simple open API type,format pair. There are
+// two ways to customize spec for a type. If you add it here, a type will be converted to a simple type and the type
+// comment (the comment that is added before type definition) will be lost. The spec will still have the property
+// comment. The second way is to implement OpenAPIDefinitionGetter interface. That function can customize the spec (so
+// the spec does not need to be simple type,format) or can even return a simple type,format (e.g. IntOrString). For simple
+// type formats, the benefit of adding OpenAPIDefinitionGetter interface is to keep both type and property documentation.
+// Example:
+// type Sample struct {
+//      ...
+//      // port of the server
+//      port IntOrString
+//      ...
+// }
+// // IntOrString documentation...
+// type IntOrString { ... }
+//
+// Adding IntOrString to this function:
+// "port" : {
+//           format:      "string",
+//           type:        "int-or-string",
+//           Description: "port of the server"
+// }
+//
+// Implement OpenAPIDefinitionGetter for IntOrString:
+//
+// "port" : {
+//           $Ref:    "#/definitions/IntOrString"
+//           Description: "port of the server"
+// }
+// ...
+// definitions:
+// {
+//           "IntOrString": {
+//                     format:      "string",
+//                     type:        "int-or-string",
+//                     Description: "IntOrString documentation..."    // new
+//           }
+// }
+//
+func OpenAPITypeFormat(typeName string) (string, string) {
+	mapped, ok := schemaTypeFormatMap[typeName]
+	if !ok {
+		return "", ""
+	}
+	return mapped.name, mapped.format
+}
+
+// Returns the zero-value for the given type along with true if the type
+// could be found.
+func OpenAPIZeroValue(typeName string) (interface{}, bool) {
+	mapped, ok := schemaTypeFormatMap[typeName]
+	if !ok {
+		return nil, false
+	}
+	return mapped.zero, true
+}
+
+func EscapeJsonPointer(p string) string {
+	// Escaping reference name using rfc6901
+	p = strings.Replace(p, "~", "~0", -1)
+	p = strings.Replace(p, "/", "~1", -1)
+	return p
+}
+
+func EmbedOpenAPIDefinitionIntoV2Extension(main OpenAPIDefinition, embedded OpenAPIDefinition) OpenAPIDefinition {
+	if main.Schema.Extensions == nil {
+		main.Schema.Extensions = make(map[string]interface{})
+	}
+	main.Schema.Extensions[ExtensionV2Schema] = embedded.Schema
+	return main
+}
+
+// GenerateOpenAPIV3OneOfSchema generate the set of schemas that MUST be assigned to SchemaProps.OneOf
+func GenerateOpenAPIV3OneOfSchema(types []string) (oneOf []spec.Schema) {
+	for _, t := range types {
+		oneOf = append(oneOf, spec.Schema{SchemaProps: spec.SchemaProps{Type: []string{t}}})
+	}
+	return
+}

vendor/k8s.io/kube-openapi/pkg/common/doc.go

@@ -0,0 +1,19 @@
+/*
+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 common holds shared code and types between open API code
+// generator and spec generator.
+package common

vendor/k8s.io/kube-openapi/pkg/common/interfaces.go

@@ -0,0 +1,88 @@
+package common
+
+// RouteContainer is the entrypoint for a service, which may contain multiple
+// routes under a common path with a common set of path parameters.
+type RouteContainer interface {
+	// RootPath is the path that all contained routes are nested under.
+	RootPath() string
+	// PathParameters are common parameters defined in the root path.
+	PathParameters() []Parameter
+	// Routes are all routes exposed under the root path.
+	Routes() []Route
+}
+
+// Route is a logical endpoint of a service.
+type Route interface {
+	// Method defines the HTTP Method.
+	Method() string
+	// Path defines the route's endpoint.
+	Path() string
+	// OperationName defines a machine-readable ID for the route.
+	OperationName() string
+	// Parameters defines the list of accepted parameters.
+	Parameters() []Parameter
+	// Description is a human-readable route description.
+	Description() string
+	// Consumes defines the consumed content-types.
+	Consumes() []string
+	// Produces defines the produced content-types.
+	Produces() []string
+	// Metadata allows adding extensions to the generated spec.
+	Metadata() map[string]interface{}
+	// RequestPayloadSample defines an example request payload. Can return nil.
+	RequestPayloadSample() interface{}
+	// ResponsePayloadSample defines an example response payload. Can return nil.
+	ResponsePayloadSample() interface{}
+	// StatusCodeResponses defines a mapping of HTTP Status Codes to the specific response(s).
+	// Multiple responses with the same HTTP Status Code are acceptable.
+	StatusCodeResponses() []StatusCodeResponse
+}
+
+// StatusCodeResponse is an explicit response type with an HTTP Status Code.
+type StatusCodeResponse interface {
+	// Code defines the HTTP Status Code.
+	Code() int
+	// Message returns the human-readable message.
+	Message() string
+	// Model defines an example payload for this response.
+	Model() interface{}
+}
+
+// Parameter is a Route parameter.
+type Parameter interface {
+	// Name defines the unique-per-route identifier.
+	Name() string
+	// Description is the human-readable description of the param.
+	Description() string
+	// Required defines if this parameter must be provided.
+	Required() bool
+	// Kind defines the type of the parameter itself.
+	Kind() ParameterKind
+	// DataType defines the type of data the parameter carries.
+	DataType() string
+	// AllowMultiple defines if more than one value can be supplied for the parameter.
+	AllowMultiple() bool
+}
+
+// ParameterKind is an enum of route parameter types.
+type ParameterKind int
+
+const (
+	// PathParameterKind indicates the request parameter type is "path".
+	PathParameterKind = ParameterKind(iota)
+
+	// QueryParameterKind indicates the request parameter type is "query".
+	QueryParameterKind
+
+	// BodyParameterKind indicates the request parameter type is "body".
+	BodyParameterKind
+
+	// HeaderParameterKind indicates the request parameter type is "header".
+	HeaderParameterKind
+
+	// FormParameterKind indicates the request parameter type is "form".
+	FormParameterKind
+
+	// UnknownParameterKind indicates the request parameter type has not been specified.
+	UnknownParameterKind
+)

vendor/k8s.io/kube-openapi/pkg/handler3/handler.go

@@ -0,0 +1,291 @@
+/*
+Copyright 2021 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 handler3
+
+import (
+	"bytes"
+	"crypto/sha512"
+	"encoding/json"
+	"fmt"
+	"mime"
+	"net/http"
+	"net/url"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	openapi_v3 "github.com/google/gnostic/openapiv3"
+	"github.com/munnerz/goautoneg"
+	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/internal/handler"
+	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+const (
+	jsonExt = ".json"
+
+	mimeJson = "application/json"
+	// TODO(mehdy): change @68f4ded to a version tag when gnostic add version tags.
+	mimePb   = "application/com.github.googleapis.gnostic.OpenAPIv3@68f4ded+protobuf"
+	mimePbGz = "application/x-gzip"
+
+	subTypeProtobuf = "com.github.proto-openapi.spec.v3@v1.0+protobuf"
+	subTypeJSON     = "json"
+)
+
+// OpenAPIV3Discovery is the format of the Discovery document for OpenAPI V3
+// It maps Discovery paths to their corresponding URLs with a hash parameter included
+type OpenAPIV3Discovery struct {
+	Paths map[string]OpenAPIV3DiscoveryGroupVersion `json:"paths"`
+}
+
+// OpenAPIV3DiscoveryGroupVersion includes information about a group version and URL
+// for accessing the OpenAPI. The URL includes a hash parameter to support client side caching
+type OpenAPIV3DiscoveryGroupVersion struct {
+	// Path is an absolute path of an OpenAPI V3 document in the form of /openapi/v3/apis/apps/v1?hash=014fbff9a07c
+	ServerRelativeURL string `json:"serverRelativeURL"`
+}
+
+// OpenAPIService is the service responsible for serving OpenAPI spec. It has
+// the ability to safely change the spec while serving it.
+type OpenAPIService struct {
+	// rwMutex protects All members of this service.
+	rwMutex      sync.RWMutex
+	lastModified time.Time
+	v3Schema     map[string]*OpenAPIV3Group
+}
+
+type OpenAPIV3Group struct {
+	rwMutex sync.RWMutex
+
+	lastModified time.Time
+
+	pbCache   handler.HandlerCache
+	jsonCache handler.HandlerCache
+	etagCache handler.HandlerCache
+}
+
+func init() {
+	mime.AddExtensionType(".json", mimeJson)
+	mime.AddExtensionType(".pb-v1", mimePb)
+	mime.AddExtensionType(".gz", mimePbGz)
+}
+
+func computeETag(data []byte) string {
+	if data == nil {
+		return ""
+	}
+	return fmt.Sprintf("%X", sha512.Sum512(data))
+}
+
+func constructServerRelativeURL(gvString, etag string) string {
+	u := url.URL{Path: path.Join("/openapi/v3", gvString)}
+	query := url.Values{}
+	query.Set("hash", etag)
+	u.RawQuery = query.Encode()
+	return u.String()
+}
+
+// NewOpenAPIService builds an OpenAPIService starting with the given spec.
+func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) {
+	o := &OpenAPIService{}
+	o.v3Schema = make(map[string]*OpenAPIV3Group)
+	return o, nil
+}
+
+func (o *OpenAPIService) getGroupBytes() ([]byte, error) {
+	o.rwMutex.RLock()
+	defer o.rwMutex.RUnlock()
+	keys := make([]string, len(o.v3Schema))
+	i := 0
+	for k := range o.v3Schema {
+		keys[i] = k
+		i++
+	}
+
+	sort.Strings(keys)
+	discovery := &OpenAPIV3Discovery{Paths: make(map[string]OpenAPIV3DiscoveryGroupVersion)}
+	for gvString, groupVersion := range o.v3Schema {
+		etagBytes, err := groupVersion.etagCache.Get()
+		if err != nil {
+			return nil, err
+		}
+		discovery.Paths[gvString] = OpenAPIV3DiscoveryGroupVersion{
+			ServerRelativeURL: constructServerRelativeURL(gvString, string(etagBytes)),
+		}
+	}
+	j, err := json.Marshal(discovery)
+	if err != nil {
+		return nil, err
+	}
+	return j, nil
+}
+
+func (o *OpenAPIService) getSingleGroupBytes(getType string, group string) ([]byte, string, time.Time, error) {
+	o.rwMutex.RLock()
+	defer o.rwMutex.RUnlock()
+	v, ok := o.v3Schema[group]
+	if !ok {
+		return nil, "", time.Now(), fmt.Errorf("Cannot find CRD group %s", group)
+	}
+	if getType == subTypeJSON {
+		specBytes, err := v.jsonCache.Get()
+		if err != nil {
+			return nil, "", v.lastModified, err
+		}
+		etagBytes, err := v.etagCache.Get()
+		return specBytes, string(etagBytes), v.lastModified, err
+	} else if getType == subTypeProtobuf {
+		specPb, err := v.pbCache.Get()
+		if err != nil {
+			return nil, "", v.lastModified, err
+		}
+		etagBytes, err := v.etagCache.Get()
+		return specPb, string(etagBytes), v.lastModified, err
+	}
+	return nil, "", time.Now(), fmt.Errorf("Invalid accept clause %s", getType)
+}
+
+func (o *OpenAPIService) UpdateGroupVersion(group string, openapi *spec3.OpenAPI) (err error) {
+	o.rwMutex.Lock()
+	defer o.rwMutex.Unlock()
+
+	if _, ok := o.v3Schema[group]; !ok {
+		o.v3Schema[group] = &OpenAPIV3Group{}
+	}
+	return o.v3Schema[group].UpdateSpec(openapi)
+}
+
+func (o *OpenAPIService) DeleteGroupVersion(group string) {
+	o.rwMutex.Lock()
+	defer o.rwMutex.Unlock()
+	delete(o.v3Schema, group)
+}
+
+func ToV3ProtoBinary(json []byte) ([]byte, error) {
+	document, err := openapi_v3.ParseDocument(json)
+	if err != nil {
+		return nil, err
+	}
+	return proto.Marshal(document)
+}
+
+func (o *OpenAPIService) HandleDiscovery(w http.ResponseWriter, r *http.Request) {
+	data, _ := o.getGroupBytes()
+	http.ServeContent(w, r, "/openapi/v3", time.Now(), bytes.NewReader(data))
+}
+
+func (o *OpenAPIService) HandleGroupVersion(w http.ResponseWriter, r *http.Request) {
+	url := strings.SplitAfterN(r.URL.Path, "/", 4)
+	group := url[3]
+
+	decipherableFormats := r.Header.Get("Accept")
+	if decipherableFormats == "" {
+		decipherableFormats = "*/*"
+	}
+	clauses := goautoneg.ParseAccept(decipherableFormats)
+	w.Header().Add("Vary", "Accept")
+
+	if len(clauses) == 0 {
+		return
+	}
+
+	accepted := []struct {
+		Type    string
+		SubType string
+	}{
+		{"application", subTypeJSON},
+		{"application", subTypeProtobuf},
+	}
+
+	for _, clause := range clauses {
+		for _, accepts := range accepted {
+			if clause.Type != accepts.Type && clause.Type != "*" {
+				continue
+			}
+			if clause.SubType != accepts.SubType && clause.SubType != "*" {
+				continue
+			}
+			data, etag, lastModified, err := o.getSingleGroupBytes(accepts.SubType, group)
+			if err != nil {
+				return
+			}
+			// ETag must be enclosed in double quotes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag
+			w.Header().Set("Etag", strconv.Quote(etag))
+
+			if hash := r.URL.Query().Get("hash"); hash != "" {
+				if hash != etag {
+					u := constructServerRelativeURL(group, etag)
+					http.Redirect(w, r, u, 301)
+					return
+				}
+				// The Vary header is required because the Accept header can
+				// change the contents returned. This prevents clients from caching
+				// protobuf as JSON and vice versa.
+				w.Header().Set("Vary", "Accept")
+
+				// Only set these headers when a hash is given.
+				w.Header().Set("Cache-Control", "public, immutable")
+				// Set the Expires directive to the maximum value of one year from the request,
+				// effectively indicating that the cache never expires.
+				w.Header().Set("Expires", time.Now().AddDate(1, 0, 0).Format(time.RFC1123))
+			}
+			http.ServeContent(w, r, "", lastModified, bytes.NewReader(data))
+			return
+		}
+	}
+	w.WriteHeader(406)
+	return
+}
+
+func (o *OpenAPIService) RegisterOpenAPIV3VersionedService(servePath string, handler common.PathHandlerByGroupVersion) error {
+	handler.Handle(servePath, http.HandlerFunc(o.HandleDiscovery))
+	handler.HandlePrefix(servePath+"/", http.HandlerFunc(o.HandleGroupVersion))
+	return nil
+}
+
+func (o *OpenAPIV3Group) UpdateSpec(openapi *spec3.OpenAPI) (err error) {
+	o.rwMutex.Lock()
+	defer o.rwMutex.Unlock()
+
+	o.jsonCache = o.jsonCache.New(func() ([]byte, error) {
+		return json.Marshal(openapi)
+	})
+	o.pbCache = o.pbCache.New(func() ([]byte, error) {
+		json, err := o.jsonCache.Get()
+		if err != nil {
+			return nil, err
+		}
+		return ToV3ProtoBinary(json)
+	})
+	// TODO: This forces a json marshal of corresponding group-versions.
+	// We should look to replace this with a faster hashing mechanism.
+	o.etagCache = o.etagCache.New(func() ([]byte, error) {
+		json, err := o.jsonCache.Get()
+		if err != nil {
+			return nil, err
+		}
+		return []byte(computeETag(json)), nil
+	})
+	o.lastModified = time.Now()
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/internal/handler/handler_cache.go

@@ -0,0 +1,57 @@
+/*
+Copyright 2021 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 handler
+
+import (
+	"sync"
+)
+
+// HandlerCache represents a lazy cache for generating a byte array
+// It is used to lazily marshal OpenAPI v2/v3 and lazily generate the ETag
+type HandlerCache struct {
+	BuildCache func() ([]byte, error)
+	once       sync.Once
+	bytes      []byte
+	err        error
+}
+
+// Get either returns the cached value or calls BuildCache() once before caching and returning
+// its results. If BuildCache returns an error, the last valid value for the cache (from prior
+// calls to New()) is used instead if possible.
+func (c *HandlerCache) Get() ([]byte, error) {
+	c.once.Do(func() {
+		bytes, err := c.BuildCache()
+		// if there is an error updating the cache, there can be situations where
+		// c.bytes contains a valid value (carried over from the previous update)
+		// but c.err is also not nil; the cache user is expected to check for this
+		c.err = err
+		if c.err == nil {
+			// don't override previous spec if we had an error
+			c.bytes = bytes
+		}
+	})
+	return c.bytes, c.err
+}
+
+// New creates a new HandlerCache for situations where a cache refresh is needed.
+// This function is not thread-safe and should not be called at the same time as Get().
+func (c *HandlerCache) New(cacheBuilder func() ([]byte, error)) HandlerCache {
+	return HandlerCache{
+		bytes:      c.bytes,
+		BuildCache: cacheBuilder,
+	}
+}

vendor/k8s.io/kube-openapi/pkg/openapiconv/convert.go

@@ -0,0 +1,322 @@
+/*
+Copyright 2022 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 openapiconv
+
+import (
+	"strings"
+
+	klog "k8s.io/klog/v2"
+	builderutil "k8s.io/kube-openapi/pkg/builder3/util"
+	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+var OpenAPIV2DefPrefix = "#/definitions/"
+var OpenAPIV3DefPrefix = "#/components/schemas/"
+
+// ConvertV2ToV3 converts an OpenAPI V2 object into V3.
+// Certain references may be shared between the V2 and V3 objects in the conversion.
+func ConvertV2ToV3(v2Spec *spec.Swagger) *spec3.OpenAPI {
+	v3Spec := &spec3.OpenAPI{
+		Version:      "3.0.0",
+		Info:         v2Spec.Info,
+		ExternalDocs: ConvertExternalDocumentation(v2Spec.ExternalDocs),
+		Paths:        ConvertPaths(v2Spec.Paths),
+		Components:   ConvertComponents(v2Spec.SecurityDefinitions, v2Spec.Definitions, v2Spec.Responses, v2Spec.Produces),
+	}
+
+	return v3Spec
+}
+
+func ConvertExternalDocumentation(v2ED *spec.ExternalDocumentation) *spec3.ExternalDocumentation {
+	if v2ED == nil {
+		return nil
+	}
+	return &spec3.ExternalDocumentation{
+		ExternalDocumentationProps: spec3.ExternalDocumentationProps{
+			Description: v2ED.Description,
+			URL:         v2ED.URL,
+		},
+	}
+}
+
+func ConvertComponents(v2SecurityDefinitions spec.SecurityDefinitions, v2Definitions spec.Definitions, v2Responses map[string]spec.Response, produces []string) *spec3.Components {
+	components := &spec3.Components{}
+
+	if v2Definitions != nil {
+		components.Schemas = make(map[string]*spec.Schema)
+	}
+	for s, schema := range v2Definitions {
+		components.Schemas[s] = ConvertSchema(&schema)
+	}
+	if v2SecurityDefinitions != nil {
+		components.SecuritySchemes = make(spec3.SecuritySchemes)
+	}
+	for s, securityScheme := range v2SecurityDefinitions {
+		components.SecuritySchemes[s] = ConvertSecurityScheme(securityScheme)
+	}
+	if v2Responses != nil {
+		components.Responses = make(map[string]*spec3.Response)
+	}
+	for r, response := range v2Responses {
+		components.Responses[r] = ConvertResponse(&response, produces)
+	}
+
+	return components
+}
+
+func ConvertSchema(v2Schema *spec.Schema) *spec.Schema {
+	if v2Schema == nil {
+		return nil
+	}
+	v3Schema := spec.Schema{
+		VendorExtensible:   v2Schema.VendorExtensible,
+		SchemaProps:        v2Schema.SchemaProps,
+		SwaggerSchemaProps: v2Schema.SwaggerSchemaProps,
+		ExtraProps:         v2Schema.ExtraProps,
+	}
+
+	if refString := v2Schema.Ref.String(); refString != "" {
+		if idx := strings.Index(refString, OpenAPIV2DefPrefix); idx != -1 {
+			v3Schema.Ref = spec.MustCreateRef(OpenAPIV3DefPrefix + refString[idx+len(OpenAPIV2DefPrefix):])
+		} else {
+			klog.Errorf("Error: Swagger V2 Ref %s does not contain #/definitions\n", refString)
+		}
+	}
+
+	if v2Schema.Properties != nil {
+		v3Schema.Properties = make(map[string]spec.Schema)
+		for key, property := range v2Schema.Properties {
+			v3Schema.Properties[key] = *ConvertSchema(&property)
+		}
+	}
+	if v2Schema.Items != nil {
+		v3Schema.Items = &spec.SchemaOrArray{
+			Schema:  ConvertSchema(v2Schema.Items.Schema),
+			Schemas: ConvertSchemaList(v2Schema.Items.Schemas),
+		}
+	}
+
+	if v2Schema.AdditionalProperties != nil {
+		v3Schema.AdditionalProperties = &spec.SchemaOrBool{
+			Schema: ConvertSchema(v2Schema.AdditionalProperties.Schema),
+			Allows: v2Schema.AdditionalProperties.Allows,
+		}
+	}
+	if v2Schema.AdditionalItems != nil {
+		v3Schema.AdditionalItems = &spec.SchemaOrBool{
+			Schema: ConvertSchema(v2Schema.AdditionalItems.Schema),
+			Allows: v2Schema.AdditionalItems.Allows,
+		}
+	}
+
+	return builderutil.WrapRefs(&v3Schema)
+}
+
+func ConvertSchemaList(v2SchemaList []spec.Schema) []spec.Schema {
+	if v2SchemaList == nil {
+		return nil
+	}
+	v3SchemaList := []spec.Schema{}
+	for _, s := range v2SchemaList {
+		v3SchemaList = append(v3SchemaList, *ConvertSchema(&s))
+	}
+	return v3SchemaList
+}
+
+func ConvertSecurityScheme(v2securityScheme *spec.SecurityScheme) *spec3.SecurityScheme {
+	if v2securityScheme == nil {
+		return nil
+	}
+	securityScheme := &spec3.SecurityScheme{
+		VendorExtensible: v2securityScheme.VendorExtensible,
+		SecuritySchemeProps: spec3.SecuritySchemeProps{
+			Description: v2securityScheme.Description,
+			Type:        v2securityScheme.Type,
+			Name:        v2securityScheme.Name,
+			In:          v2securityScheme.In,
+		},
+	}
+
+	if v2securityScheme.Flow != "" {
+		securityScheme.Flows = make(map[string]*spec3.OAuthFlow)
+		securityScheme.Flows[v2securityScheme.Flow] = &spec3.OAuthFlow{
+			OAuthFlowProps: spec3.OAuthFlowProps{
+				AuthorizationUrl: v2securityScheme.AuthorizationURL,
+				TokenUrl:         v2securityScheme.TokenURL,
+				Scopes:           v2securityScheme.Scopes,
+			},
+		}
+	}
+	return securityScheme
+}
+
+func ConvertPaths(v2Paths *spec.Paths) *spec3.Paths {
+	if v2Paths == nil {
+		return nil
+	}
+	paths := &spec3.Paths{
+		VendorExtensible: v2Paths.VendorExtensible,
+	}
+
+	if v2Paths.Paths != nil {
+		paths.Paths = make(map[string]*spec3.Path)
+	}
+	for k, v := range v2Paths.Paths {
+		paths.Paths[k] = ConvertPathItem(v)
+	}
+	return paths
+}
+
+func ConvertPathItem(v2pathItem spec.PathItem) *spec3.Path {
+	path := &spec3.Path{
+		Refable: v2pathItem.Refable,
+		PathProps: spec3.PathProps{
+			Get:     ConvertOperation(v2pathItem.Get),
+			Put:     ConvertOperation(v2pathItem.Put),
+			Post:    ConvertOperation(v2pathItem.Post),
+			Delete:  ConvertOperation(v2pathItem.Delete),
+			Options: ConvertOperation(v2pathItem.Options),
+			Head:    ConvertOperation(v2pathItem.Head),
+			Patch:   ConvertOperation(v2pathItem.Patch),
+		},
+		VendorExtensible: v2pathItem.VendorExtensible,
+	}
+	for _, param := range v2pathItem.Parameters {
+		path.Parameters = append(path.Parameters, ConvertParameter(param))
+	}
+	return path
+}
+
+func ConvertOperation(v2Operation *spec.Operation) *spec3.Operation {
+	if v2Operation == nil {
+		return nil
+	}
+	operation := &spec3.Operation{
+		VendorExtensible: v2Operation.VendorExtensible,
+		OperationProps: spec3.OperationProps{
+			Description:  v2Operation.Description,
+			ExternalDocs: ConvertExternalDocumentation(v2Operation.OperationProps.ExternalDocs),
+			Tags:         v2Operation.Tags,
+			Summary:      v2Operation.Summary,
+			Deprecated:   v2Operation.Deprecated,
+			OperationId:  v2Operation.ID,
+		},
+	}
+
+	for _, param := range v2Operation.Parameters {
+		if param.ParamProps.Name == "body" && param.ParamProps.Schema != nil {
+			operation.OperationProps.RequestBody = &spec3.RequestBody{
+				RequestBodyProps: spec3.RequestBodyProps{},
+			}
+			if v2Operation.Consumes != nil {
+				operation.RequestBody.Content = make(map[string]*spec3.MediaType)
+			}
+			for _, consumer := range v2Operation.Consumes {
+				operation.RequestBody.Content[consumer] = &spec3.MediaType{
+					MediaTypeProps: spec3.MediaTypeProps{
+						Schema: ConvertSchema(param.ParamProps.Schema),
+					},
+				}
+			}
+		} else {
+			operation.Parameters = append(operation.Parameters, ConvertParameter(param))
+		}
+	}
+
+	operation.Responses = &spec3.Responses{ResponsesProps: spec3.ResponsesProps{
+		Default: ConvertResponse(v2Operation.Responses.Default, v2Operation.Produces),
+	},
+		VendorExtensible: v2Operation.Responses.VendorExtensible,
+	}
+
+	if v2Operation.Responses.StatusCodeResponses != nil {
+		operation.Responses.StatusCodeResponses = make(map[int]*spec3.Response)
+	}
+	for k, v := range v2Operation.Responses.StatusCodeResponses {
+		operation.Responses.StatusCodeResponses[k] = ConvertResponse(&v, v2Operation.Produces)
+	}
+	return operation
+}
+
+func ConvertResponse(v2Response *spec.Response, produces []string) *spec3.Response {
+	if v2Response == nil {
+		return nil
+	}
+	response := &spec3.Response{
+		Refable:          ConvertRefableResponse(v2Response.Refable),
+		VendorExtensible: v2Response.VendorExtensible,
+		ResponseProps: spec3.ResponseProps{
+			Description: v2Response.Description,
+		},
+	}
+
+	if v2Response.Schema != nil {
+		if produces != nil {
+			response.Content = make(map[string]*spec3.MediaType)
+		}
+		for _, producer := range produces {
+			response.ResponseProps.Content[producer] = &spec3.MediaType{
+				MediaTypeProps: spec3.MediaTypeProps{
+					Schema: ConvertSchema(v2Response.Schema),
+				},
+			}
+		}
+	}
+	return response
+}
+
+func ConvertParameter(v2Param spec.Parameter) *spec3.Parameter {
+	param := &spec3.Parameter{
+		Refable:          ConvertRefableParameter(v2Param.Refable),
+		VendorExtensible: v2Param.VendorExtensible,
+		ParameterProps: spec3.ParameterProps{
+			Name:            v2Param.Name,
+			Description:     v2Param.Description,
+			In:              v2Param.In,
+			Required:        v2Param.Required,
+			Schema:          ConvertSchema(v2Param.Schema),
+			AllowEmptyValue: v2Param.AllowEmptyValue,
+		},
+	}
+	// Convert SimpleSchema into Schema
+	if param.Schema == nil {
+		param.Schema = &spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:        []string{v2Param.Type},
+				Format:      v2Param.Format,
+				UniqueItems: v2Param.UniqueItems,
+			},
+		}
+	}
+
+	return param
+}
+
+func ConvertRefableParameter(refable spec.Refable) spec.Refable {
+	if refable.Ref.String() != "" {
+		return spec.Refable{Ref: spec.MustCreateRef(strings.Replace(refable.Ref.String(), "#/parameters/", "#/components/parameters/", 1))}
+	}
+	return refable
+}
+
+func ConvertRefableResponse(refable spec.Refable) spec.Refable {
+	if refable.Ref.String() != "" {
+		return spec.Refable{Ref: spec.MustCreateRef(strings.Replace(refable.Ref.String(), "#/responses/", "#/components/responses/", 1))}
+	}
+	return refable
+}

vendor/k8s.io/kube-openapi/pkg/schemamutation/walker.go

@@ -0,0 +1,519 @@
+/*
+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 schemamutation
+
+import (
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// Walker runs callback functions on all references of an OpenAPI spec,
+// replacing the values when visiting corresponding types.
+type Walker struct {
+	// SchemaCallback will be called on each schema, taking the original schema,
+	// and before any other callbacks of the Walker.
+	// If the schema needs to be mutated, DO NOT mutate it in-place,
+	// always create a copy, mutate, and return it.
+	SchemaCallback func(schema *spec.Schema) *spec.Schema
+
+	// RefCallback will be called on each ref.
+	// If the ref needs to be mutated, DO NOT mutate it in-place,
+	// always create a copy, mutate, and return it.
+	RefCallback func(ref *spec.Ref) *spec.Ref
+}
+
+type SchemaCallbackFunc func(schema *spec.Schema) *spec.Schema
+type RefCallbackFunc func(ref *spec.Ref) *spec.Ref
+
+var SchemaCallBackNoop SchemaCallbackFunc = func(schema *spec.Schema) *spec.Schema {
+	return schema
+}
+var RefCallbackNoop RefCallbackFunc = func(ref *spec.Ref) *spec.Ref {
+	return ref
+}
+
+// ReplaceReferences rewrites the references without mutating the input.
+// The output might share data with the input.
+func ReplaceReferences(walkRef func(ref *spec.Ref) *spec.Ref, sp *spec.Swagger) *spec.Swagger {
+	walker := &Walker{RefCallback: walkRef, SchemaCallback: SchemaCallBackNoop}
+	return walker.WalkRoot(sp)
+}
+
+func (w *Walker) WalkSchema(schema *spec.Schema) *spec.Schema {
+	if schema == nil {
+		return nil
+	}
+
+	orig := schema
+	clone := func() {
+		if orig == schema {
+			schema = &spec.Schema{}
+			*schema = *orig
+		}
+	}
+
+	// Always run callback on the whole schema first
+	// so that SchemaCallback can take the original schema as input.
+	schema = w.SchemaCallback(schema)
+
+	if r := w.RefCallback(&schema.Ref); r != &schema.Ref {
+		clone()
+		schema.Ref = *r
+	}
+
+	definitionsCloned := false
+	for k, v := range schema.Definitions {
+		if s := w.WalkSchema(&v); s != &v {
+			if !definitionsCloned {
+				definitionsCloned = true
+				clone()
+				schema.Definitions = make(spec.Definitions, len(orig.Definitions))
+				for k2, v2 := range orig.Definitions {
+					schema.Definitions[k2] = v2
+				}
+			}
+			schema.Definitions[k] = *s
+		}
+	}
+
+	propertiesCloned := false
+	for k, v := range schema.Properties {
+		if s := w.WalkSchema(&v); s != &v {
+			if !propertiesCloned {
+				propertiesCloned = true
+				clone()
+				schema.Properties = make(map[string]spec.Schema, len(orig.Properties))
+				for k2, v2 := range orig.Properties {
+					schema.Properties[k2] = v2
+				}
+			}
+			schema.Properties[k] = *s
+		}
+	}
+
+	patternPropertiesCloned := false
+	for k, v := range schema.PatternProperties {
+		if s := w.WalkSchema(&v); s != &v {
+			if !patternPropertiesCloned {
+				patternPropertiesCloned = true
+				clone()
+				schema.PatternProperties = make(map[string]spec.Schema, len(orig.PatternProperties))
+				for k2, v2 := range orig.PatternProperties {
+					schema.PatternProperties[k2] = v2
+				}
+			}
+			schema.PatternProperties[k] = *s
+		}
+	}
+
+	allOfCloned := false
+	for i := range schema.AllOf {
+		if s := w.WalkSchema(&schema.AllOf[i]); s != &schema.AllOf[i] {
+			if !allOfCloned {
+				allOfCloned = true
+				clone()
+				schema.AllOf = make([]spec.Schema, len(orig.AllOf))
+				copy(schema.AllOf, orig.AllOf)
+			}
+			schema.AllOf[i] = *s
+		}
+	}
+
+	anyOfCloned := false
+	for i := range schema.AnyOf {
+		if s := w.WalkSchema(&schema.AnyOf[i]); s != &schema.AnyOf[i] {
+			if !anyOfCloned {
+				anyOfCloned = true
+				clone()
+				schema.AnyOf = make([]spec.Schema, len(orig.AnyOf))
+				copy(schema.AnyOf, orig.AnyOf)
+			}
+			schema.AnyOf[i] = *s
+		}
+	}
+
+	oneOfCloned := false
+	for i := range schema.OneOf {
+		if s := w.WalkSchema(&schema.OneOf[i]); s != &schema.OneOf[i] {
+			if !oneOfCloned {
+				oneOfCloned = true
+				clone()
+				schema.OneOf = make([]spec.Schema, len(orig.OneOf))
+				copy(schema.OneOf, orig.OneOf)
+			}
+			schema.OneOf[i] = *s
+		}
+	}
+
+	if schema.Not != nil {
+		if s := w.WalkSchema(schema.Not); s != schema.Not {
+			clone()
+			schema.Not = s
+		}
+	}
+
+	if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil {
+		if s := w.WalkSchema(schema.AdditionalProperties.Schema); s != schema.AdditionalProperties.Schema {
+			clone()
+			schema.AdditionalProperties = &spec.SchemaOrBool{Schema: s, Allows: schema.AdditionalProperties.Allows}
+		}
+	}
+
+	if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil {
+		if s := w.WalkSchema(schema.AdditionalItems.Schema); s != schema.AdditionalItems.Schema {
+			clone()
+			schema.AdditionalItems = &spec.SchemaOrBool{Schema: s, Allows: schema.AdditionalItems.Allows}
+		}
+	}
+
+	if schema.Items != nil {
+		if schema.Items.Schema != nil {
+			if s := w.WalkSchema(schema.Items.Schema); s != schema.Items.Schema {
+				clone()
+				schema.Items = &spec.SchemaOrArray{Schema: s}
+			}
+		} else {
+			itemsCloned := false
+			for i := range schema.Items.Schemas {
+				if s := w.WalkSchema(&schema.Items.Schemas[i]); s != &schema.Items.Schemas[i] {
+					if !itemsCloned {
+						clone()
+						schema.Items = &spec.SchemaOrArray{
+							Schemas: make([]spec.Schema, len(orig.Items.Schemas)),
+						}
+						itemsCloned = true
+						copy(schema.Items.Schemas, orig.Items.Schemas)
+					}
+					schema.Items.Schemas[i] = *s
+				}
+			}
+		}
+	}
+
+	return schema
+}
+
+func (w *Walker) walkParameter(param *spec.Parameter) *spec.Parameter {
+	if param == nil {
+		return nil
+	}
+
+	orig := param
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			param = &spec.Parameter{}
+			*param = *orig
+		}
+	}
+
+	if r := w.RefCallback(&param.Ref); r != &param.Ref {
+		clone()
+		param.Ref = *r
+	}
+	if s := w.WalkSchema(param.Schema); s != param.Schema {
+		clone()
+		param.Schema = s
+	}
+	if param.Items != nil {
+		if r := w.RefCallback(&param.Items.Ref); r != &param.Items.Ref {
+			param.Items.Ref = *r
+		}
+	}
+
+	return param
+}
+
+func (w *Walker) walkParameters(params []spec.Parameter) ([]spec.Parameter, bool) {
+	if params == nil {
+		return nil, false
+	}
+
+	orig := params
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			params = make([]spec.Parameter, len(params))
+			copy(params, orig)
+		}
+	}
+
+	for i := range params {
+		if s := w.walkParameter(&params[i]); s != &params[i] {
+			clone()
+			params[i] = *s
+		}
+	}
+
+	return params, cloned
+}
+
+func (w *Walker) walkResponse(resp *spec.Response) *spec.Response {
+	if resp == nil {
+		return nil
+	}
+
+	orig := resp
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			resp = &spec.Response{}
+			*resp = *orig
+		}
+	}
+
+	if r := w.RefCallback(&resp.Ref); r != &resp.Ref {
+		clone()
+		resp.Ref = *r
+	}
+	if s := w.WalkSchema(resp.Schema); s != resp.Schema {
+		clone()
+		resp.Schema = s
+	}
+
+	return resp
+}
+
+func (w *Walker) walkResponses(resps *spec.Responses) *spec.Responses {
+	if resps == nil {
+		return nil
+	}
+
+	orig := resps
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			resps = &spec.Responses{}
+			*resps = *orig
+		}
+	}
+
+	if r := w.walkResponse(resps.ResponsesProps.Default); r != resps.ResponsesProps.Default {
+		clone()
+		resps.Default = r
+	}
+
+	responsesCloned := false
+	for k, v := range resps.ResponsesProps.StatusCodeResponses {
+		if r := w.walkResponse(&v); r != &v {
+			if !responsesCloned {
+				responsesCloned = true
+				clone()
+				resps.ResponsesProps.StatusCodeResponses = make(map[int]spec.Response, len(orig.StatusCodeResponses))
+				for k2, v2 := range orig.StatusCodeResponses {
+					resps.ResponsesProps.StatusCodeResponses[k2] = v2
+				}
+			}
+			resps.ResponsesProps.StatusCodeResponses[k] = *r
+		}
+	}
+
+	return resps
+}
+
+func (w *Walker) walkOperation(op *spec.Operation) *spec.Operation {
+	if op == nil {
+		return nil
+	}
+
+	orig := op
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			op = &spec.Operation{}
+			*op = *orig
+		}
+	}
+
+	parametersCloned := false
+	for i := range op.Parameters {
+		if s := w.walkParameter(&op.Parameters[i]); s != &op.Parameters[i] {
+			if !parametersCloned {
+				parametersCloned = true
+				clone()
+				op.Parameters = make([]spec.Parameter, len(orig.Parameters))
+				copy(op.Parameters, orig.Parameters)
+			}
+			op.Parameters[i] = *s
+		}
+	}
+
+	if r := w.walkResponses(op.Responses); r != op.Responses {
+		clone()
+		op.Responses = r
+	}
+
+	return op
+}
+
+func (w *Walker) walkPathItem(pathItem *spec.PathItem) *spec.PathItem {
+	if pathItem == nil {
+		return nil
+	}
+
+	orig := pathItem
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			pathItem = &spec.PathItem{}
+			*pathItem = *orig
+		}
+	}
+
+	if p, changed := w.walkParameters(pathItem.Parameters); changed {
+		clone()
+		pathItem.Parameters = p
+	}
+	if op := w.walkOperation(pathItem.Get); op != pathItem.Get {
+		clone()
+		pathItem.Get = op
+	}
+	if op := w.walkOperation(pathItem.Head); op != pathItem.Head {
+		clone()
+		pathItem.Head = op
+	}
+	if op := w.walkOperation(pathItem.Delete); op != pathItem.Delete {
+		clone()
+		pathItem.Delete = op
+	}
+	if op := w.walkOperation(pathItem.Options); op != pathItem.Options {
+		clone()
+		pathItem.Options = op
+	}
+	if op := w.walkOperation(pathItem.Patch); op != pathItem.Patch {
+		clone()
+		pathItem.Patch = op
+	}
+	if op := w.walkOperation(pathItem.Post); op != pathItem.Post {
+		clone()
+		pathItem.Post = op
+	}
+	if op := w.walkOperation(pathItem.Put); op != pathItem.Put {
+		clone()
+		pathItem.Put = op
+	}
+
+	return pathItem
+}
+
+func (w *Walker) walkPaths(paths *spec.Paths) *spec.Paths {
+	if paths == nil {
+		return nil
+	}
+
+	orig := paths
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			paths = &spec.Paths{}
+			*paths = *orig
+		}
+	}
+
+	pathsCloned := false
+	for k, v := range paths.Paths {
+		if p := w.walkPathItem(&v); p != &v {
+			if !pathsCloned {
+				pathsCloned = true
+				clone()
+				paths.Paths = make(map[string]spec.PathItem, len(orig.Paths))
+				for k2, v2 := range orig.Paths {
+					paths.Paths[k2] = v2
+				}
+			}
+			paths.Paths[k] = *p
+		}
+	}
+
+	return paths
+}
+
+func (w *Walker) WalkRoot(swagger *spec.Swagger) *spec.Swagger {
+	if swagger == nil {
+		return nil
+	}
+
+	orig := swagger
+	cloned := false
+	clone := func() {
+		if !cloned {
+			cloned = true
+			swagger = &spec.Swagger{}
+			*swagger = *orig
+		}
+	}
+
+	parametersCloned := false
+	for k, v := range swagger.Parameters {
+		if p := w.walkParameter(&v); p != &v {
+			if !parametersCloned {
+				parametersCloned = true
+				clone()
+				swagger.Parameters = make(map[string]spec.Parameter, len(orig.Parameters))
+				for k2, v2 := range orig.Parameters {
+					swagger.Parameters[k2] = v2
+				}
+			}
+			swagger.Parameters[k] = *p
+		}
+	}
+
+	responsesCloned := false
+	for k, v := range swagger.Responses {
+		if r := w.walkResponse(&v); r != &v {
+			if !responsesCloned {
+				responsesCloned = true
+				clone()
+				swagger.Responses = make(map[string]spec.Response, len(orig.Responses))
+				for k2, v2 := range orig.Responses {
+					swagger.Responses[k2] = v2
+				}
+			}
+			swagger.Responses[k] = *r
+		}
+	}
+
+	definitionsCloned := false
+	for k, v := range swagger.Definitions {
+		if s := w.WalkSchema(&v); s != &v {
+			if !definitionsCloned {
+				definitionsCloned = true
+				clone()
+				swagger.Definitions = make(spec.Definitions, len(orig.Definitions))
+				for k2, v2 := range orig.Definitions {
+					swagger.Definitions[k2] = v2
+				}
+			}
+			swagger.Definitions[k] = *s
+		}
+	}
+
+	if swagger.Paths != nil {
+		if p := w.walkPaths(swagger.Paths); p != swagger.Paths {
+			clone()
+			swagger.Paths = p
+		}
+	}
+
+	return swagger
+}

vendor/k8s.io/kube-openapi/pkg/spec3/component.go

@@ -0,0 +1,47 @@
+/*
+Copyright 2021 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 spec3
+
+import "k8s.io/kube-openapi/pkg/validation/spec"
+
+// Components holds a set of reusable objects for different aspects of the OAS.
+// All objects defined within the components object will have no effect on the API
+// unless they are explicitly referenced from properties outside the components object.
+//
+// more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#componentsObject
+type Components struct {
+	// Schemas holds reusable Schema Objects
+	Schemas map[string]*spec.Schema `json:"schemas,omitempty"`
+	// SecuritySchemes holds reusable Security Scheme Objects, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject
+	SecuritySchemes SecuritySchemes `json:"securitySchemes,omitempty"`
+	// Responses holds reusable Responses Objects
+	Responses map[string]*Response `json:"responses,omitempty"`
+	// Parameters holds reusable Parameters Objects
+	Parameters map[string]*Parameter `json:"parameters,omitempty"`
+	// Example holds reusable Example objects
+	Examples map[string]*Example `json:"examples,omitempty"`
+	// RequestBodies holds reusable Request Body objects
+	RequestBodies map[string]*RequestBody `json:"requestBodies,omitempty"`
+	// Links is a map of operations links that can be followed from the response
+	Links map[string]*Link `json:"links,omitempty"`
+	// Headers holds a maps of a headers name to its definition
+	Headers map[string]*Header `json:"headers,omitempty"`
+	// all fields are defined at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#componentsObject
+}
+
+// SecuritySchemes holds reusable Security Scheme Objects, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject
+type SecuritySchemes map[string]*SecurityScheme

vendor/k8s.io/kube-openapi/pkg/spec3/encoding.go

@@ -0,0 +1,64 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"github.com/go-openapi/swag"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+type Encoding struct {
+	EncodingProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Encoding as JSON
+func (e *Encoding) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(e.EncodingProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(e.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (e *Encoding) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &e.EncodingProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &e.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+type EncodingProps struct {
+	// Content Type for encoding a specific property
+	ContentType string `json:"contentType,omitempty"`
+	// A map allowing additional information to be provided as headers
+	Headers map[string]*Header `json:"headers,omitempty"`
+	// Describes how a specific property value will be serialized depending on its type
+	Style string `json:"style,omitempty"`
+	// When this is true, property values of type array or object generate separate parameters for each value of the array, or key-value-pair of the map. For other types of properties this property has no effect
+	Explode string `json:"explode,omitempty"`
+	// AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986
+	AllowReserved bool `json:"allowReserved,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/example.go

@@ -0,0 +1,73 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// Example https://swagger.io/specification/#example-object
+
+type Example struct {
+	spec.Refable
+	ExampleProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON
+func (e *Example) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(e.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(e.ExampleProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(e.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (e *Example) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &e.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &e.ExampleProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &e.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+type ExampleProps struct {
+	// Summary holds a short description of the example
+	Summary string `json:"summary,omitempty"`
+	// Description holds a long description of the example
+	Description string `json:"description,omitempty"`
+	// Embedded literal example.
+	Value interface{} `json:"value,omitempty"`
+	// A URL that points to the literal example. This provides the capability to reference examples that cannot easily be included in JSON or YAML documents.
+	ExternalValue string `json:"externalValue,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/external_documentation.go

@@ -0,0 +1,58 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+type ExternalDocumentation struct {
+	ExternalDocumentationProps
+	spec.VendorExtensible
+}
+
+type ExternalDocumentationProps struct {
+	// Description is a short description of the target documentation. CommonMark syntax MAY be used for rich text representation.
+	Description string `json:"description,omitempty"`
+	// URL is the URL for the target documentation.
+	URL string `json:"url"`
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
+func (e *ExternalDocumentation) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(e.ExternalDocumentationProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(e.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (e *ExternalDocumentation) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &e.ExternalDocumentationProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &e.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/spec3/header.go

@@ -0,0 +1,90 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// Header a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject
+//
+// Note that this struct is actually a thin wrapper around HeaderProps to make it referable and extensible
+type Header struct {
+	spec.Refable
+	HeaderProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Header as JSON
+func (h *Header) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(h.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(h.HeaderProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(h.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (h *Header) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &h.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &h.HeaderProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &h.VendorExtensible); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// HeaderProps a struct that describes a header object
+type HeaderProps struct {
+	// Description holds a brief description of the parameter
+	Description string `json:"description,omitempty"`
+	// Required determines whether this parameter is mandatory
+	Required bool `json:"required,omitempty"`
+	// Deprecated declares this operation to be deprecated
+	Deprecated bool `json:"deprecated,omitempty"`
+	// AllowEmptyValue sets the ability to pass empty-valued parameters
+	AllowEmptyValue bool `json:"allowEmptyValue,omitempty"`
+	// Style describes how the parameter value will be serialized depending on the type of the parameter value
+	Style string `json:"style,omitempty"`
+	// Explode when true, parameter values of type array or object generate separate parameters for each value of the array or key-value pair of the map
+	Explode bool `json:"explode,omitempty"`
+	// AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986
+	AllowReserved bool `json:"allowReserved,omitempty"`
+	// Schema holds the schema defining the type used for the parameter
+	Schema *spec.Schema `json:"schema,omitempty"`
+	// Content holds a map containing the representations for the parameter
+	Content map[string]*MediaType `json:"content,omitempty"`
+	// Example of the header
+	Example interface{} `json:"example,omitempty"`
+	// Examples of the header
+	Examples map[string]*Example `json:"examples,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/media_type.go

@@ -0,0 +1,66 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"github.com/go-openapi/swag"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// MediaType a struct that allows you to specify content format, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#mediaTypeObject
+//
+// Note that this struct is actually a thin wrapper around MediaTypeProps to make it referable and extensible
+type MediaType struct {
+	MediaTypeProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode MediaType as JSON
+func (m *MediaType) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(m.MediaTypeProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(m.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (m *MediaType) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &m.MediaTypeProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &m.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+// MediaTypeProps a struct that allows you to specify content format, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#mediaTypeObject
+type MediaTypeProps struct {
+	// Schema holds the schema defining the type used for the media type
+	Schema    *spec.Schema `json:"schema,omitempty"`
+	// Example of the media type
+	Example interface{} `json:"example,omitempty"`
+	// Examples of the media type. Each example object should match the media type and specific schema if present
+	Examples map[string]*Example `json:"examples,omitempty"`
+	// A map between a property name and its encoding information. The key, being the property name, MUST exist in the schema as a property. The encoding object SHALL only apply to requestBody objects when the media type is multipart or application/x-www-form-urlencoded
+	Encoding map[string]*Encoding `json:"encoding,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/operation.go

@@ -0,0 +1,79 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// Operation describes a single API operation on a path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#operationObject
+//
+// Note that this struct is actually a thin wrapper around OperationProps to make it referable and extensible
+type Operation struct {
+	OperationProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Operation as JSON
+func (o *Operation) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(o.OperationProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(o.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (o *Operation) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &o.OperationProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &o.VendorExtensible)
+}
+
+// OperationProps describes a single API operation on a path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#operationObject
+type OperationProps struct {
+	// Tags holds a list of tags for API documentation control
+	Tags []string `json:"tags,omitempty"`
+	// Summary holds a short summary of what the operation does
+	Summary string `json:"summary,omitempty"`
+	// Description holds a verbose explanation of the operation behavior
+	Description string `json:"description,omitempty"`
+	// ExternalDocs holds additional external documentation for this operation
+	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
+	// OperationId holds a unique string used to identify the operation
+	OperationId string `json:"operationId,omitempty"`
+	// Parameters a list of parameters that are applicable for this operation
+	Parameters []*Parameter `json:"parameters,omitempty"`
+	// RequestBody holds the request body applicable for this operation
+	RequestBody *RequestBody `json:"requestBody,omitempty"`
+	// Responses holds the list of possible responses as they are returned from executing this operation
+	Responses *Responses `json:"responses,omitempty"`
+	// Deprecated declares this operation to be deprecated
+	Deprecated bool `json:"deprecated,omitempty"`
+	// SecurityRequirement holds a declaration of which security mechanisms can be used for this operation
+	SecurityRequirement []*SecurityRequirement `json:"security,omitempty"`
+	// Servers contains an alternative server array to service this operation
+	Servers []*Server `json:"servers,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/parameter.go

@@ -0,0 +1,94 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// Parameter a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject
+//
+// Note that this struct is actually a thin wrapper around ParameterProps to make it referable and extensible
+type Parameter struct {
+	spec.Refable
+	ParameterProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Parameter as JSON
+func (p *Parameter) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(p.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(p.ParameterProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (p *Parameter) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &p.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.ParameterProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.VendorExtensible); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ParameterProps a struct that describes a single operation parameter, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#parameterObject
+type ParameterProps struct {
+	// Name holds the name of the parameter
+	Name string `json:"name,omitempty"`
+	// In holds the location of the parameter
+	In string `json:"in,omitempty"`
+	// Description holds a brief description of the parameter
+	Description string `json:"description,omitempty"`
+	// Required determines whether this parameter is mandatory
+	Required bool `json:"required,omitempty"`
+	// Deprecated declares this operation to be deprecated
+	Deprecated bool `json:"deprecated,omitempty"`
+	// AllowEmptyValue sets the ability to pass empty-valued parameters
+	AllowEmptyValue bool `json:"allowEmptyValue,omitempty"`
+	// Style describes how the parameter value will be serialized depending on the type of the parameter value
+	Style string `json:"style,omitempty"`
+	// Explode when true, parameter values of type array or object generate separate parameters for each value of the array or key-value pair of the map
+	Explode bool `json:"explode,omitempty"`
+	// AllowReserved determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986
+	AllowReserved bool `json:"allowReserved,omitempty"`
+	// Schema holds the schema defining the type used for the parameter
+	Schema *spec.Schema `json:"schema,omitempty"`
+	// Content holds a map containing the representations for the parameter
+	Content map[string]*MediaType `json:"content,omitempty"`
+	// Example of the parameter's potential value
+	Example interface{} `json:"example,omitempty"`
+	// Examples of the parameter's potential value. Each example SHOULD contain a value in the correct format as specified in the parameter encoding
+	Examples map[string]*Example `json:"examples,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/path.go

@@ -0,0 +1,142 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"strings"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// Paths describes the available paths and operations for the API, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathsObject
+type Paths struct {
+	Paths map[string]*Path
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Paths as JSON
+func (p *Paths) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(p.Paths)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (p *Paths) UnmarshalJSON(data []byte) error {
+	var res map[string]json.RawMessage
+	if err := json.Unmarshal(data, &res); err != nil {
+		return err
+	}
+	for k, v := range res {
+		if strings.HasPrefix(strings.ToLower(k), "x-") {
+			if p.Extensions == nil {
+				p.Extensions = make(map[string]interface{})
+			}
+			var d interface{}
+			if err := json.Unmarshal(v, &d); err != nil {
+				return err
+			}
+			p.Extensions[k] = d
+		}
+		if strings.HasPrefix(k, "/") {
+			if p.Paths == nil {
+				p.Paths = make(map[string]*Path)
+			}
+			var pi *Path
+			if err := json.Unmarshal(v, &pi); err != nil {
+				return err
+			}
+			p.Paths[k] = pi
+		}
+	}
+	return nil
+}
+
+// Path describes the operations available on a single path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathItemObject
+//
+// Note that this struct is actually a thin wrapper around PathProps to make it referable and extensible
+type Path struct {
+	spec.Refable
+	PathProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Path as JSON
+func (p *Path) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(p.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(p.PathProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (p *Path) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &p.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.PathProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PathProps describes the operations available on a single path, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#pathItemObject
+type PathProps struct {
+	// Summary holds a summary for all operations in this path
+	Summary string `json:"summary,omitempty"`
+	// Description holds a description for all operations in this path
+	Description string `json:"description,omitempty"`
+	// Get defines GET operation
+	Get *Operation `json:"get,omitempty"`
+	// Put defines PUT operation
+	Put *Operation `json:"put,omitempty"`
+	// Post defines POST operation
+	Post *Operation `json:"post,omitempty"`
+	// Delete defines DELETE operation
+	Delete *Operation `json:"delete,omitempty"`
+	// Options defines OPTIONS operation
+	Options *Operation `json:"options,omitempty"`
+	// Head defines HEAD operation
+	Head *Operation `json:"head,omitempty"`
+	// Patch defines PATCH operation
+	Patch *Operation `json:"patch,omitempty"`
+	// Trace defines TRACE operation
+	Trace *Operation `json:"trace,omitempty"`
+	// Servers is an alternative server array to service all operations in this path
+	Servers []*Server `json:"servers,omitempty"`
+	// Parameters a list of parameters that are applicable for this operation
+	Parameters []*Parameter `json:"parameters,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/request_body.go

@@ -0,0 +1,73 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// RequestBody describes a single request body, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#requestBodyObject
+//
+// Note that this struct is actually a thin wrapper around RequestBodyProps to make it referable and extensible
+type RequestBody struct {
+	spec.Refable
+	RequestBodyProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode RequestBody as JSON
+func (r *RequestBody) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.RequestBodyProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (r *RequestBody) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.RequestBodyProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+// RequestBodyProps describes a single request body, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#requestBodyObject
+type RequestBodyProps struct {
+	// Description holds a brief description of the request body
+	Description string `json:"description,omitempty"`
+	// Content is the content of the request body. The key is a media type or media type range and the value describes it
+	Content map[string]*MediaType `json:"content,omitempty"`
+	// Required determines if the request body is required in the request
+	Required bool `json:"required,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/response.go

@@ -0,0 +1,203 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// Responses holds the list of possible responses as they are returned from executing this operation
+//
+// Note that this struct is actually a thin wrapper around ResponsesProps to make it referable and extensible
+type Responses struct {
+	ResponsesProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
+func (r *Responses) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.ResponsesProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (r *Responses) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.ResponsesProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ResponsesProps holds the list of possible responses as they are returned from executing this operation
+type ResponsesProps struct {
+	// Default holds the documentation of responses other than the ones declared for specific HTTP response codes. Use this field to cover undeclared responses
+	Default *Response `json:"-"`
+	// StatusCodeResponses holds a map of any HTTP status code to the response definition
+	StatusCodeResponses map[int]*Response `json:"-"`
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode ResponsesProps as JSON
+func (r ResponsesProps) MarshalJSON() ([]byte, error) {
+	toser := map[string]*Response{}
+	if r.Default != nil {
+		toser["default"] = r.Default
+	}
+	for k, v := range r.StatusCodeResponses {
+		toser[strconv.Itoa(k)] = v
+	}
+	return json.Marshal(toser)
+}
+
+// UnmarshalJSON unmarshals responses from JSON
+func (r *ResponsesProps) UnmarshalJSON(data []byte) error {
+	var res map[string]*Response
+	if err := json.Unmarshal(data, &res); err != nil {
+		return nil
+	}
+	if v, ok := res["default"]; ok {
+		r.Default = v
+		delete(res, "default")
+	}
+	for k, v := range res {
+		if nk, err := strconv.Atoi(k); err == nil {
+			if r.StatusCodeResponses == nil {
+				r.StatusCodeResponses = map[int]*Response{}
+			}
+			r.StatusCodeResponses[nk] = v
+		}
+	}
+	return nil
+}
+
+// Response describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject
+//
+// Note that this struct is actually a thin wrapper around ResponseProps to make it referable and extensible
+type Response struct {
+	spec.Refable
+	ResponseProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Response as JSON
+func (r *Response) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.ResponseProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (r *Response) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.ResponseProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ResponseProps describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject
+type ResponseProps struct {
+	// Description holds a short description of the response
+	Description string `json:"description,omitempty"`
+	// Headers holds a maps of a headers name to its definition
+	Headers map[string]*Header `json:"headers,omitempty"`
+	// Content holds a map containing descriptions of potential response payloads
+	Content map[string]*MediaType `json:"content,omitempty"`
+	// Links is a map of operations links that can be followed from the response
+	Links map[string]*Link `json:"links,omitempty"`
+}
+
+
+// Link represents a possible design-time link for a response, more at https://swagger.io/specification/#link-object
+type Link struct {
+	spec.Refable
+	LinkProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Link as JSON
+func (r *Link) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.LinkProps)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+func (r *Link) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.LinkProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// LinkProps describes a single response from an API Operation, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject
+type LinkProps struct {
+	// OperationId is the name of an existing, resolvable OAS operation
+	OperationId string `json:"operationId,omitempty"`
+	// Parameters is a map representing parameters to pass to an operation as specified with operationId or identified via operationRef
+	Parameters map[string]interface{} `json:"parameters,omitempty"`
+	// Description holds a description of the link
+	Description string `json:"description,omitempty"`
+	// RequestBody is a literal value or expresion to use as a request body when calling the target operation
+	RequestBody interface{} `json:"requestBody,omitempty"`
+	// Server holds a server object used by the target operation
+	Server *Server `json:"server,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/security_requirement.go

@@ -0,0 +1,56 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// SecurityRequirementProps describes the required security schemes to execute an operation, more at https://swagger.io/specification/#security-requirement-object
+//
+// Note that this struct is actually a thin wrapper around SecurityRequirementProps to make it referable and extensible
+type SecurityRequirement struct {
+	SecurityRequirementProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode SecurityRequirement as JSON
+func (s *SecurityRequirement) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.SecurityRequirementProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (s *SecurityRequirement) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &s.SecurityRequirementProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &s.VendorExtensible)
+}
+
+// SecurityRequirementProps describes the required security schemes to execute an operation, more at https://swagger.io/specification/#security-requirement-object
+type SecurityRequirementProps map[string][]string

vendor/k8s.io/kube-openapi/pkg/spec3/security_scheme.go

@@ -0,0 +1,118 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+)
+
+// SecurityScheme defines reusable Security Scheme Object, more at https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#securitySchemeObject
+type SecurityScheme struct {
+	spec.Refable
+	SecuritySchemeProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode SecurityScheme as JSON
+func (s *SecurityScheme) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.SecuritySchemeProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(s.Refable)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (s *SecurityScheme) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &s.VendorExtensible); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &s.Refable)
+}
+
+// SecuritySchemeProps defines a security scheme that can be used by the operations
+type SecuritySchemeProps struct {
+	// Type of the security scheme
+	Type string `json:"type,omitempty"`
+	// Description holds a short description for security scheme
+	Description string `json:"description,omitempty"`
+	// Name holds the name of the header, query or cookie parameter to be used
+	Name string `json:"name,omitempty"`
+	// In holds the location of the API key
+	In string `json:"in,omitempty"`
+	// Scheme holds the name of the HTTP Authorization scheme to be used in the Authorization header
+	Scheme string `json:"scheme,omitempty"`
+	// BearerFormat holds a hint to the client to identify how the bearer token is formatted
+	BearerFormat string `json:"bearerFormat,omitempty"`
+	// Flows contains configuration information for the flow types supported.
+	Flows map[string]*OAuthFlow `json:"flows,omitempty"`
+	// OpenIdConnectUrl holds an url to discover OAuth2 configuration values from
+	OpenIdConnectUrl string `json:"openIdConnectUrl,omitempty"`
+}
+
+// OAuthFlow contains configuration information for the flow types supported.
+type OAuthFlow struct {
+	OAuthFlowProps
+	spec.VendorExtensible
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode OAuthFlow as JSON
+func (o *OAuthFlow) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(o.OAuthFlowProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(o.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (o *OAuthFlow) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &o.OAuthFlowProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &o.VendorExtensible)
+}
+
+// OAuthFlowProps holds configuration details for a supported OAuth Flow
+type OAuthFlowProps struct {
+	// AuthorizationUrl hold the authorization URL to be used for this flow
+	AuthorizationUrl string `json:"authorizationUrl,omitempty"`
+	// TokenUrl holds the token URL to be used for this flow
+	TokenUrl string `json:"tokenUrl,omitempty"`
+	// RefreshUrl holds the URL to be used for obtaining refresh tokens
+	RefreshUrl string `json:"refreshUrl,omitempty"`
+	// Scopes holds the available scopes for the OAuth2 security scheme
+	Scopes map[string]string `json:"scopes,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/spec3/server.go

@@ -0,0 +1,98 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"encoding/json"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+	"github.com/go-openapi/swag"
+
+)
+
+type Server struct {
+	ServerProps
+	spec.VendorExtensible
+}
+
+type ServerProps struct {
+	// Description is a short description of the target documentation. CommonMark syntax MAY be used for rich text representation.
+	Description string `json:"description,omitempty"`
+	// URL is the URL for the target documentation.
+	URL string `json:"url"`
+	// Variables contains a map between a variable name and its value. The value is used for substitution in the server's URL templeate
+	Variables map[string]*ServerVariable `json:"variables,omitempty"`
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
+func (s *Server) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.ServerProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (s *Server) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &s.ServerProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &s.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}
+
+type ServerVariable struct {
+	ServerVariableProps
+	spec.VendorExtensible
+}
+
+type ServerVariableProps struct {
+	// Enum is an enumeration of string values to be used if the substitution options are from a limited set
+	Enum []string `json:"enum,omitempty"`
+	// Default is the default value to use for substitution, which SHALL be sent if an alternate value is not supplied
+	Default string `json:"default"`
+	// Description is a description for the server variable
+	Description string `json:"description,omitempty"`
+}
+
+// MarshalJSON is a custom marshal function that knows how to encode Responses as JSON
+func (s *ServerVariable) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.ServerVariableProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+func (s *ServerVariable) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &s.ServerVariableProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &s.VendorExtensible); err != nil {
+		return err
+	}
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/spec3/spec.go

@@ -0,0 +1,37 @@
+/*
+Copyright 2021 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 spec3
+
+import (
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+// OpenAPI is an object that describes an API and conforms to the OpenAPI Specification.
+type OpenAPI struct {
+	// Version represents the semantic version number of the OpenAPI Specification that this document uses
+	Version string `json:"openapi"`
+	// Info provides metadata about the API
+	Info *spec.Info `json:"info"`
+	// Paths holds the available target and operations for the API
+	Paths *Paths `json:"paths,omitempty"`
+	// Servers is an array of Server objects which provide connectivity information to a target server
+	Servers []*Server `json:"servers,omitempty"`
+	// Components hold various schemas for the specification
+	Components *Components `json:"components,omitempty"`
+	// ExternalDocs holds additional external documentation
+	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/util/proto/document.go

@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
+	openapi_v2 "github.com/google/gnostic/openapiv2"
 	"gopkg.in/yaml.v2"
 )
 

vendor/k8s.io/kube-openapi/pkg/util/proto/document_v3.go

@@ -0,0 +1,324 @@
+/*
+Copyright 2022 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 proto
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	openapi_v3 "github.com/google/gnostic/openapiv3"
+	"gopkg.in/yaml.v3"
+)
+
+// Temporary parse implementation to be used until gnostic->kube-openapi conversion
+// is possible.
+func NewOpenAPIV3Data(doc *openapi_v3.Document) (Models, error) {
+	definitions := Definitions{
+		models: map[string]Schema{},
+	}
+
+	schemas := doc.GetComponents().GetSchemas()
+	if schemas == nil {
+		return &definitions, nil
+	}
+
+	// Save the list of all models first. This will allow us to
+	// validate that we don't have any dangling reference.
+	for _, namedSchema := range schemas.GetAdditionalProperties() {
+		definitions.models[namedSchema.GetName()] = nil
+	}
+
+	// Now, parse each model. We can validate that references exists.
+	for _, namedSchema := range schemas.GetAdditionalProperties() {
+		path := NewPath(namedSchema.GetName())
+		val := namedSchema.GetValue()
+
+		if val == nil {
+			continue
+		}
+
+		if schema, err := definitions.ParseV3SchemaOrReference(namedSchema.GetValue(), &path); err != nil {
+			return nil, err
+		} else if schema != nil {
+			// Schema may be nil if we hit incompleteness in the conversion,
+			// but not a fatal error
+			definitions.models[namedSchema.GetName()] = schema
+		}
+	}
+
+	return &definitions, nil
+}
+
+func (d *Definitions) ParseV3SchemaReference(s *openapi_v3.Reference, path *Path) (Schema, error) {
+	base := &BaseSchema{
+		Description: s.Description,
+	}
+
+	if !strings.HasPrefix(s.GetXRef(), "#/components/schemas") {
+		// Only resolve references to components/schemas. We may add support
+		// later for other in-spec paths, but otherwise treat unrecognized
+		// refs as arbitrary/unknown values.
+		return &Arbitrary{
+			BaseSchema: *base,
+		}, nil
+	}
+
+	reference := strings.TrimPrefix(s.GetXRef(), "#/components/schemas/")
+	if _, ok := d.models[reference]; !ok {
+		return nil, newSchemaError(path, "unknown model in reference: %q", reference)
+	}
+
+	return &Ref{
+		BaseSchema: BaseSchema{
+			Description: s.Description,
+		},
+		reference:   reference,
+		definitions: d,
+	}, nil
+}
+
+func (d *Definitions) ParseV3SchemaOrReference(s *openapi_v3.SchemaOrReference, path *Path) (Schema, error) {
+	var schema Schema
+	var err error
+
+	switch v := s.GetOneof().(type) {
+	case *openapi_v3.SchemaOrReference_Reference:
+		// Any references stored in #!/components/... are bound to refer
+		// to external documents. This API does not support such a
+		// feature.
+		//
+		// In the weird case that this is a reference to a schema that is
+		// not external, we attempt to parse anyway
+		schema, err = d.ParseV3SchemaReference(v.Reference, path)
+	case *openapi_v3.SchemaOrReference_Schema:
+		schema, err = d.ParseSchemaV3(v.Schema, path)
+	default:
+		panic("unexpected type")
+	}
+
+	return schema, err
+}
+
+// ParseSchema creates a walkable Schema from an openapi v3 schema. While
+// this function is public, it doesn't leak through the interface.
+func (d *Definitions) ParseSchemaV3(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	switch s.GetType() {
+	case object:
+		for _, extension := range s.GetSpecificationExtension() {
+			if extension.Name == "x-kuberentes-group-version-kind" {
+				// Objects with x-kubernetes-group-version-kind are always top
+				// level types.
+				return d.parseV3Kind(s, path)
+			}
+		}
+
+		if len(s.GetProperties().GetAdditionalProperties()) > 0 {
+			return d.parseV3Kind(s, path)
+		}
+		return d.parseV3Map(s, path)
+	case array:
+		return d.parseV3Array(s, path)
+	case String, Number, Integer, Boolean:
+		return d.parseV3Primitive(s, path)
+	default:
+		return d.parseV3Arbitrary(s, path)
+	}
+}
+
+func (d *Definitions) parseV3Kind(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	if s.GetType() != object {
+		return nil, newSchemaError(path, "invalid object type")
+	} else if s.GetProperties() == nil {
+		return nil, newSchemaError(path, "object doesn't have properties")
+	}
+
+	fields := map[string]Schema{}
+	fieldOrder := []string{}
+
+	for _, namedSchema := range s.GetProperties().GetAdditionalProperties() {
+		var err error
+		name := namedSchema.GetName()
+		path := path.FieldPath(name)
+		fields[name], err = d.ParseV3SchemaOrReference(namedSchema.GetValue(), &path)
+		if err != nil {
+			return nil, err
+		}
+		fieldOrder = append(fieldOrder, name)
+	}
+
+	base, err := d.parseV3BaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Kind{
+		BaseSchema:     *base,
+		RequiredFields: s.GetRequired(),
+		Fields:         fields,
+		FieldOrder:     fieldOrder,
+	}, nil
+}
+
+func (d *Definitions) parseV3Arbitrary(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	base, err := d.parseV3BaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
+	return &Arbitrary{
+		BaseSchema: *base,
+	}, nil
+}
+
+func (d *Definitions) parseV3Primitive(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	switch s.GetType() {
+	case String: // do nothing
+	case Number: // do nothing
+	case Integer: // do nothing
+	case Boolean: // do nothing
+	default:
+		// Unsupported primitive type. Treat as arbitrary type
+		return d.parseV3Arbitrary(s, path)
+	}
+
+	base, err := d.parseV3BaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Primitive{
+		BaseSchema: *base,
+		Type:       s.GetType(),
+		Format:     s.GetFormat(),
+	}, nil
+}
+
+func (d *Definitions) parseV3Array(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	if s.GetType() != array {
+		return nil, newSchemaError(path, `array should have type "array"`)
+	} else if len(s.GetItems().GetSchemaOrReference()) != 1 {
+		// This array can have multiple types in it (or no types at all)
+		// This is not supported by this conversion.
+		// Just return an arbitrary type
+		return d.parseV3Arbitrary(s, path)
+	}
+
+	sub, err := d.ParseV3SchemaOrReference(s.GetItems().GetSchemaOrReference()[0], path)
+	if err != nil {
+		return nil, err
+	}
+
+	base, err := d.parseV3BaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
+	return &Array{
+		BaseSchema: *base,
+		SubType:    sub,
+	}, nil
+}
+
+// We believe the schema is a map, verify and return a new schema
+func (d *Definitions) parseV3Map(s *openapi_v3.Schema, path *Path) (Schema, error) {
+	if s.GetType() != object {
+		return nil, newSchemaError(path, "invalid object type")
+	}
+	var sub Schema
+
+	switch p := s.GetAdditionalProperties().GetOneof().(type) {
+	case *openapi_v3.AdditionalPropertiesItem_Boolean:
+		// What does this boolean even mean?
+		base, err := d.parseV3BaseSchema(s, path)
+		if err != nil {
+			return nil, err
+		}
+		sub = &Arbitrary{
+			BaseSchema: *base,
+		}
+	case *openapi_v3.AdditionalPropertiesItem_SchemaOrReference:
+		if schema, err := d.ParseV3SchemaOrReference(p.SchemaOrReference, path); err != nil {
+			return nil, err
+		} else {
+			sub = schema
+		}
+	case nil:
+		// no subtype?
+		sub = &Arbitrary{}
+	default:
+		panic("unrecognized type " + reflect.TypeOf(p).Name())
+	}
+
+	base, err := d.parseV3BaseSchema(s, path)
+	if err != nil {
+		return nil, err
+	}
+	return &Map{
+		BaseSchema: *base,
+		SubType:    sub,
+	}, nil
+}
+
+func parseV3Interface(def *yaml.Node) (interface{}, error) {
+	if def == nil {
+		return nil, nil
+	}
+	var i interface{}
+	if err := def.Decode(&i); err != nil {
+		return nil, err
+	}
+	return i, nil
+}
+
+func (d *Definitions) parseV3BaseSchema(s *openapi_v3.Schema, path *Path) (*BaseSchema, error) {
+	if s == nil {
+		return nil, fmt.Errorf("cannot initializae BaseSchema from nil")
+	}
+
+	def, err := parseV3Interface(s.GetDefault().ToRawInfo())
+	if err != nil {
+		return nil, err
+	}
+
+	return &BaseSchema{
+		Description: s.GetDescription(),
+		Default:     def,
+		Extensions:  SpecificationExtensionToMap(s.GetSpecificationExtension()),
+		Path:        *path,
+	}, nil
+}
+
+func SpecificationExtensionToMap(e []*openapi_v3.NamedAny) map[string]interface{} {
+	values := map[string]interface{}{}
+
+	for _, na := range e {
+		if na.GetName() == "" || na.GetValue() == nil {
+			continue
+		}
+		if na.GetValue().GetYaml() == "" {
+			continue
+		}
+		var value interface{}
+		err := yaml.Unmarshal([]byte(na.GetValue().GetYaml()), &value)
+		if err != nil {
+			continue
+		}
+
+		values[na.GetName()] = value
+	}
+
+	return values
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/.gitignore

@@ -0,0 +1,2 @@
+secrets.yml
+coverage.out

vendor/k8s.io/kube-openapi/pkg/validation/spec/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

vendor/k8s.io/kube-openapi/pkg/validation/spec/contact_info.go

@@ -0,0 +1,24 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+// ContactInfo contact information for the exposed API.
+//
+// For more information: http://goo.gl/8us55a#contactObject
+type ContactInfo struct {
+	Name  string `json:"name,omitempty"`
+	URL   string `json:"url,omitempty"`
+	Email string `json:"email,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/external_docs.go

@@ -0,0 +1,24 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+// ExternalDocumentation allows referencing an external resource for
+// extended documentation.
+//
+// For more information: http://goo.gl/8us55a#externalDocumentationObject
+type ExternalDocumentation struct {
+	Description string `json:"description,omitempty"`
+	URL         string `json:"url,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/header.go

@@ -0,0 +1,75 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+const (
+	jsonArray = "array"
+)
+
+// HeaderProps describes a response header
+type HeaderProps struct {
+	Description string `json:"description,omitempty"`
+}
+
+// Header describes a header for a response of the API
+//
+// For more information: http://goo.gl/8us55a#headerObject
+type Header struct {
+	CommonValidations
+	SimpleSchema
+	VendorExtensible
+	HeaderProps
+}
+
+// MarshalJSON marshal this to JSON
+func (h Header) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(h.CommonValidations)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(h.SimpleSchema)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(h.HeaderProps)
+	if err != nil {
+		return nil, err
+	}
+	b4, err := json.Marshal(h.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3, b4), nil
+}
+
+// UnmarshalJSON unmarshals this header from JSON
+func (h *Header) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &h.CommonValidations); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &h.SimpleSchema); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &h.VendorExtensible); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &h.HeaderProps)
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/info.go

@@ -0,0 +1,174 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/go-openapi/swag"
+)
+
+// Extensions vendor specific extensions
+type Extensions map[string]interface{}
+
+// Add adds a value to these extensions
+func (e Extensions) Add(key string, value interface{}) {
+	realKey := strings.ToLower(key)
+	e[realKey] = value
+}
+
+// GetString gets a string value from the extensions
+func (e Extensions) GetString(key string) (string, bool) {
+	if v, ok := e[strings.ToLower(key)]; ok {
+		str, ok := v.(string)
+		return str, ok
+	}
+	return "", false
+}
+
+// GetBool gets a string value from the extensions
+func (e Extensions) GetBool(key string) (bool, bool) {
+	if v, ok := e[strings.ToLower(key)]; ok {
+		str, ok := v.(bool)
+		return str, ok
+	}
+	return false, false
+}
+
+// GetStringSlice gets a string value from the extensions
+func (e Extensions) GetStringSlice(key string) ([]string, bool) {
+	if v, ok := e[strings.ToLower(key)]; ok {
+		arr, isSlice := v.([]interface{})
+		if !isSlice {
+			return nil, false
+		}
+		var strs []string
+		for _, iface := range arr {
+			str, isString := iface.(string)
+			if !isString {
+				return nil, false
+			}
+			strs = append(strs, str)
+		}
+		return strs, ok
+	}
+	return nil, false
+}
+
+// GetObject gets the object value from the extensions.
+// out must be a json serializable type; the json go struct
+// tags of out are used to populate it.
+func (e Extensions) GetObject(key string, out interface{}) error {
+	// This json serialization/deserialization could be replaced with
+	// an approach using reflection if the optimization becomes justified.
+	if v, ok := e[strings.ToLower(key)]; ok {
+		b, err := json.Marshal(v)
+		if err != nil {
+			return err
+		}
+		err = json.Unmarshal(b, out)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// VendorExtensible composition block.
+type VendorExtensible struct {
+	Extensions Extensions
+}
+
+// AddExtension adds an extension to this extensible object
+func (v *VendorExtensible) AddExtension(key string, value interface{}) {
+	if value == nil {
+		return
+	}
+	if v.Extensions == nil {
+		v.Extensions = make(map[string]interface{})
+	}
+	v.Extensions.Add(key, value)
+}
+
+// MarshalJSON marshals the extensions to json
+func (v VendorExtensible) MarshalJSON() ([]byte, error) {
+	toser := make(map[string]interface{})
+	for k, v := range v.Extensions {
+		lk := strings.ToLower(k)
+		if strings.HasPrefix(lk, "x-") {
+			toser[k] = v
+		}
+	}
+	return json.Marshal(toser)
+}
+
+// UnmarshalJSON for this extensible object
+func (v *VendorExtensible) UnmarshalJSON(data []byte) error {
+	var d map[string]interface{}
+	if err := json.Unmarshal(data, &d); err != nil {
+		return err
+	}
+	for k, vv := range d {
+		lk := strings.ToLower(k)
+		if strings.HasPrefix(lk, "x-") {
+			if v.Extensions == nil {
+				v.Extensions = map[string]interface{}{}
+			}
+			v.Extensions[k] = vv
+		}
+	}
+	return nil
+}
+
+// InfoProps the properties for an info definition
+type InfoProps struct {
+	Description    string       `json:"description,omitempty"`
+	Title          string       `json:"title,omitempty"`
+	TermsOfService string       `json:"termsOfService,omitempty"`
+	Contact        *ContactInfo `json:"contact,omitempty"`
+	License        *License     `json:"license,omitempty"`
+	Version        string       `json:"version,omitempty"`
+}
+
+// Info object provides metadata about the API.
+// The metadata can be used by the clients if needed, and can be presented in the Swagger-UI for convenience.
+//
+// For more information: http://goo.gl/8us55a#infoObject
+type Info struct {
+	VendorExtensible
+	InfoProps
+}
+
+// MarshalJSON marshal this to JSON
+func (i Info) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(i.InfoProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(i.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON marshal this from JSON
+func (i *Info) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &i.InfoProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &i.VendorExtensible)
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/items.go

@@ -0,0 +1,109 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+const (
+	jsonRef = "$ref"
+)
+
+// SimpleSchema describe swagger simple schemas for parameters and headers
+type SimpleSchema struct {
+	Type             string      `json:"type,omitempty"`
+	Nullable         bool        `json:"nullable,omitempty"`
+	Format           string      `json:"format,omitempty"`
+	Items            *Items      `json:"items,omitempty"`
+	CollectionFormat string      `json:"collectionFormat,omitempty"`
+	Default          interface{} `json:"default,omitempty"`
+	Example          interface{} `json:"example,omitempty"`
+}
+
+// CommonValidations describe common JSON-schema validations
+type CommonValidations struct {
+	Maximum          *float64      `json:"maximum,omitempty"`
+	ExclusiveMaximum bool          `json:"exclusiveMaximum,omitempty"`
+	Minimum          *float64      `json:"minimum,omitempty"`
+	ExclusiveMinimum bool          `json:"exclusiveMinimum,omitempty"`
+	MaxLength        *int64        `json:"maxLength,omitempty"`
+	MinLength        *int64        `json:"minLength,omitempty"`
+	Pattern          string        `json:"pattern,omitempty"`
+	MaxItems         *int64        `json:"maxItems,omitempty"`
+	MinItems         *int64        `json:"minItems,omitempty"`
+	UniqueItems      bool          `json:"uniqueItems,omitempty"`
+	MultipleOf       *float64      `json:"multipleOf,omitempty"`
+	Enum             []interface{} `json:"enum,omitempty"`
+}
+
+// Items a limited subset of JSON-Schema's items object.
+// It is used by parameter definitions that are not located in "body".
+//
+// For more information: http://goo.gl/8us55a#items-object
+type Items struct {
+	Refable
+	CommonValidations
+	SimpleSchema
+	VendorExtensible
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (i *Items) UnmarshalJSON(data []byte) error {
+	var validations CommonValidations
+	if err := json.Unmarshal(data, &validations); err != nil {
+		return err
+	}
+	var ref Refable
+	if err := json.Unmarshal(data, &ref); err != nil {
+		return err
+	}
+	var simpleSchema SimpleSchema
+	if err := json.Unmarshal(data, &simpleSchema); err != nil {
+		return err
+	}
+	var vendorExtensible VendorExtensible
+	if err := json.Unmarshal(data, &vendorExtensible); err != nil {
+		return err
+	}
+	i.Refable = ref
+	i.CommonValidations = validations
+	i.SimpleSchema = simpleSchema
+	i.VendorExtensible = vendorExtensible
+	return nil
+}
+
+// MarshalJSON converts this items object to JSON
+func (i Items) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(i.CommonValidations)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(i.SimpleSchema)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(i.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b4, err := json.Marshal(i.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b4, b3, b1, b2), nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/license.go

@@ -0,0 +1,23 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+// License information for the exposed API.
+//
+// For more information: http://goo.gl/8us55a#licenseObject
+type License struct {
+	Name string `json:"name,omitempty"`
+	URL  string `json:"url,omitempty"`
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/operation.go

@@ -0,0 +1,96 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// OperationProps describes an operation
+//
+// NOTES:
+// - schemes, when present must be from [http, https, ws, wss]: see validate
+// - Security is handled as a special case: see MarshalJSON function
+type OperationProps struct {
+	Description  string                 `json:"description,omitempty"`
+	Consumes     []string               `json:"consumes,omitempty"`
+	Produces     []string               `json:"produces,omitempty"`
+	Schemes      []string               `json:"schemes,omitempty"`
+	Tags         []string               `json:"tags,omitempty"`
+	Summary      string                 `json:"summary,omitempty"`
+	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
+	ID           string                 `json:"operationId,omitempty"`
+	Deprecated   bool                   `json:"deprecated,omitempty"`
+	Security     []map[string][]string  `json:"security,omitempty"`
+	Parameters   []Parameter            `json:"parameters,omitempty"`
+	Responses    *Responses             `json:"responses,omitempty"`
+}
+
+// MarshalJSON takes care of serializing operation properties to JSON
+//
+// We use a custom marhaller here to handle a special cases related to
+// the Security field. We need to preserve zero length slice
+// while omitting the field when the value is nil/unset.
+func (op OperationProps) MarshalJSON() ([]byte, error) {
+	type Alias OperationProps
+	if op.Security == nil {
+		return json.Marshal(&struct {
+			Security []map[string][]string `json:"security,omitempty"`
+			*Alias
+		}{
+			Security: op.Security,
+			Alias:    (*Alias)(&op),
+		})
+	}
+	return json.Marshal(&struct {
+		Security []map[string][]string `json:"security"`
+		*Alias
+	}{
+		Security: op.Security,
+		Alias:    (*Alias)(&op),
+	})
+}
+
+// Operation describes a single API operation on a path.
+//
+// For more information: http://goo.gl/8us55a#operationObject
+type Operation struct {
+	VendorExtensible
+	OperationProps
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (o *Operation) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &o.OperationProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &o.VendorExtensible)
+}
+
+// MarshalJSON converts this items object to JSON
+func (o Operation) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(o.OperationProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(o.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	concated := swag.ConcatJSON(b1, b2)
+	return concated, nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/parameter.go

@@ -0,0 +1,111 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// ParamProps describes the specific attributes of an operation parameter
+//
+// NOTE:
+// - Schema is defined when "in" == "body": see validate
+// - AllowEmptyValue is allowed where "in" == "query" || "formData"
+type ParamProps struct {
+	Description     string  `json:"description,omitempty"`
+	Name            string  `json:"name,omitempty"`
+	In              string  `json:"in,omitempty"`
+	Required        bool    `json:"required,omitempty"`
+	Schema          *Schema `json:"schema,omitempty"`
+	AllowEmptyValue bool    `json:"allowEmptyValue,omitempty"`
+}
+
+// Parameter a unique parameter is defined by a combination of a [name](#parameterName) and [location](#parameterIn).
+//
+// There are five possible parameter types.
+// * Path - Used together with [Path Templating](#pathTemplating), where the parameter value is actually part
+//   of the operation's URL. This does not include the host or base path of the API. For example, in `/items/{itemId}`,
+//   the path parameter is `itemId`.
+// * Query - Parameters that are appended to the URL. For example, in `/items?id=###`, the query parameter is `id`.
+// * Header - Custom headers that are expected as part of the request.
+// * Body - The payload that's appended to the HTTP request. Since there can only be one payload, there can only be
+//   _one_ body parameter. The name of the body parameter has no effect on the parameter itself and is used for
+//   documentation purposes only. Since Form parameters are also in the payload, body and form parameters cannot exist
+//   together for the same operation.
+// * Form - Used to describe the payload of an HTTP request when either `application/x-www-form-urlencoded` or
+//   `multipart/form-data` are used as the content type of the request (in Swagger's definition,
+//   the [`consumes`](#operationConsumes) property of an operation). This is the only parameter type that can be used
+//   to send files, thus supporting the `file` type. Since form parameters are sent in the payload, they cannot be
+//   declared together with a body parameter for the same operation. Form parameters have a different format based on
+//   the content-type used (for further details, consult http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4).
+//   * `application/x-www-form-urlencoded` - Similar to the format of Query parameters but as a payload.
+//   For example, `foo=1&bar=swagger` - both `foo` and `bar` are form parameters. This is normally used for simple
+//   parameters that are being transferred.
+//   * `multipart/form-data` - each parameter takes a section in the payload with an internal header.
+//   For example, for the header `Content-Disposition: form-data; name="submit-name"` the name of the parameter is
+//   `submit-name`. This type of form parameters is more commonly used for file transfers.
+//
+// For more information: http://goo.gl/8us55a#parameterObject
+type Parameter struct {
+	Refable
+	CommonValidations
+	SimpleSchema
+	VendorExtensible
+	ParamProps
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (p *Parameter) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &p.CommonValidations); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.SimpleSchema); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.VendorExtensible); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &p.ParamProps)
+}
+
+// MarshalJSON converts this items object to JSON
+func (p Parameter) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(p.CommonValidations)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(p.SimpleSchema)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(p.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b4, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	b5, err := json.Marshal(p.ParamProps)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b3, b1, b2, b4, b5), nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/path_item.go

@@ -0,0 +1,74 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// PathItemProps the path item specific properties
+type PathItemProps struct {
+	Get        *Operation  `json:"get,omitempty"`
+	Put        *Operation  `json:"put,omitempty"`
+	Post       *Operation  `json:"post,omitempty"`
+	Delete     *Operation  `json:"delete,omitempty"`
+	Options    *Operation  `json:"options,omitempty"`
+	Head       *Operation  `json:"head,omitempty"`
+	Patch      *Operation  `json:"patch,omitempty"`
+	Parameters []Parameter `json:"parameters,omitempty"`
+}
+
+// PathItem describes the operations available on a single path.
+// A Path Item may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering).
+// The path itself is still exposed to the documentation viewer but they will
+// not know which operations and parameters are available.
+//
+// For more information: http://goo.gl/8us55a#pathItemObject
+type PathItem struct {
+	Refable
+	VendorExtensible
+	PathItemProps
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (p *PathItem) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &p.Refable); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &p.VendorExtensible); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &p.PathItemProps)
+}
+
+// MarshalJSON converts this items object to JSON
+func (p PathItem) MarshalJSON() ([]byte, error) {
+	b3, err := json.Marshal(p.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b4, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	b5, err := json.Marshal(p.PathItemProps)
+	if err != nil {
+		return nil, err
+	}
+	concated := swag.ConcatJSON(b3, b4, b5)
+	return concated, nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/paths.go

@@ -0,0 +1,85 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/go-openapi/swag"
+)
+
+// Paths holds the relative paths to the individual endpoints.
+// The path is appended to the [`basePath`](http://goo.gl/8us55a#swaggerBasePath) in order
+// to construct the full URL.
+// The Paths may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering).
+//
+// For more information: http://goo.gl/8us55a#pathsObject
+type Paths struct {
+	VendorExtensible
+	Paths map[string]PathItem `json:"-"` // custom serializer to flatten this, each entry must start with "/"
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (p *Paths) UnmarshalJSON(data []byte) error {
+	var res map[string]json.RawMessage
+	if err := json.Unmarshal(data, &res); err != nil {
+		return err
+	}
+	for k, v := range res {
+		if strings.HasPrefix(strings.ToLower(k), "x-") {
+			if p.Extensions == nil {
+				p.Extensions = make(map[string]interface{})
+			}
+			var d interface{}
+			if err := json.Unmarshal(v, &d); err != nil {
+				return err
+			}
+			p.Extensions[k] = d
+		}
+		if strings.HasPrefix(k, "/") {
+			if p.Paths == nil {
+				p.Paths = make(map[string]PathItem)
+			}
+			var pi PathItem
+			if err := json.Unmarshal(v, &pi); err != nil {
+				return err
+			}
+			p.Paths[k] = pi
+		}
+	}
+	return nil
+}
+
+// MarshalJSON converts this items object to JSON
+func (p Paths) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(p.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+
+	pths := make(map[string]PathItem)
+	for k, v := range p.Paths {
+		if strings.HasPrefix(k, "/") {
+			pths[k] = v
+		}
+	}
+	b2, err := json.Marshal(pths)
+	if err != nil {
+		return nil, err
+	}
+	concated := swag.ConcatJSON(b1, b2)
+	return concated, nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/ref.go

@@ -0,0 +1,167 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"github.com/go-openapi/jsonreference"
+)
+
+// Refable is a struct for things that accept a $ref property
+type Refable struct {
+	Ref Ref
+}
+
+// MarshalJSON marshals the ref to json
+func (r Refable) MarshalJSON() ([]byte, error) {
+	return r.Ref.MarshalJSON()
+}
+
+// UnmarshalJSON unmarshalss the ref from json
+func (r *Refable) UnmarshalJSON(d []byte) error {
+	return json.Unmarshal(d, &r.Ref)
+}
+
+// Ref represents a json reference that is potentially resolved
+type Ref struct {
+	jsonreference.Ref
+}
+
+// RemoteURI gets the remote uri part of the ref
+func (r *Ref) RemoteURI() string {
+	if r.String() == "" {
+		return r.String()
+	}
+
+	u := *r.GetURL()
+	u.Fragment = ""
+	return u.String()
+}
+
+// IsValidURI returns true when the url the ref points to can be found
+func (r *Ref) IsValidURI(basepaths ...string) bool {
+	if r.String() == "" {
+		return true
+	}
+
+	v := r.RemoteURI()
+	if v == "" {
+		return true
+	}
+
+	if r.HasFullURL {
+		rr, err := http.Get(v)
+		if err != nil {
+			return false
+		}
+
+		return rr.StatusCode/100 == 2
+	}
+
+	if !(r.HasFileScheme || r.HasFullFilePath || r.HasURLPathOnly) {
+		return false
+	}
+
+	// check for local file
+	pth := v
+	if r.HasURLPathOnly {
+		base := "."
+		if len(basepaths) > 0 {
+			base = filepath.Dir(filepath.Join(basepaths...))
+		}
+		p, e := filepath.Abs(filepath.ToSlash(filepath.Join(base, pth)))
+		if e != nil {
+			return false
+		}
+		pth = p
+	}
+
+	fi, err := os.Stat(filepath.ToSlash(pth))
+	if err != nil {
+		return false
+	}
+
+	return !fi.IsDir()
+}
+
+// Inherits creates a new reference from a parent and a child
+// If the child cannot inherit from the parent, an error is returned
+func (r *Ref) Inherits(child Ref) (*Ref, error) {
+	ref, err := r.Ref.Inherits(child.Ref)
+	if err != nil {
+		return nil, err
+	}
+	return &Ref{Ref: *ref}, nil
+}
+
+// NewRef creates a new instance of a ref object
+// returns an error when the reference uri is an invalid uri
+func NewRef(refURI string) (Ref, error) {
+	ref, err := jsonreference.New(refURI)
+	if err != nil {
+		return Ref{}, err
+	}
+	return Ref{Ref: ref}, nil
+}
+
+// MustCreateRef creates a ref object but panics when refURI is invalid.
+// Use the NewRef method for a version that returns an error.
+func MustCreateRef(refURI string) Ref {
+	return Ref{Ref: jsonreference.MustCreateRef(refURI)}
+}
+
+// MarshalJSON marshals this ref into a JSON object
+func (r Ref) MarshalJSON() ([]byte, error) {
+	str := r.String()
+	if str == "" {
+		if r.IsRoot() {
+			return []byte(`{"$ref":""}`), nil
+		}
+		return []byte("{}"), nil
+	}
+	v := map[string]interface{}{"$ref": str}
+	return json.Marshal(v)
+}
+
+// UnmarshalJSON unmarshals this ref from a JSON object
+func (r *Ref) UnmarshalJSON(d []byte) error {
+	var v map[string]interface{}
+	if err := json.Unmarshal(d, &v); err != nil {
+		return err
+	}
+	return r.fromMap(v)
+}
+
+func (r *Ref) fromMap(v map[string]interface{}) error {
+	if v == nil {
+		return nil
+	}
+
+	if vv, ok := v["$ref"]; ok {
+		if str, ok := vv.(string); ok {
+			ref, err := jsonreference.New(str)
+			if err != nil {
+				return err
+			}
+			*r = Ref{Ref: ref}
+		}
+	}
+
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/response.go

@@ -0,0 +1,78 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// ResponseProps properties specific to a response
+type ResponseProps struct {
+	Description string                 `json:"description,omitempty"`
+	Schema      *Schema                `json:"schema,omitempty"`
+	Headers     map[string]Header      `json:"headers,omitempty"`
+	Examples    map[string]interface{} `json:"examples,omitempty"`
+}
+
+// Response describes a single response from an API Operation.
+//
+// For more information: http://goo.gl/8us55a#responseObject
+type Response struct {
+	Refable
+	ResponseProps
+	VendorExtensible
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (r *Response) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.ResponseProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.Refable); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &r.VendorExtensible)
+}
+
+// MarshalJSON converts this items object to JSON
+func (r Response) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.ResponseProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.Refable)
+	if err != nil {
+		return nil, err
+	}
+	b3, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2, b3), nil
+}
+
+// NewResponse creates a new response instance
+func NewResponse() *Response {
+	return new(Response)
+}
+
+// ResponseRef creates a response as a json reference
+func ResponseRef(url string) *Response {
+	resp := NewResponse()
+	resp.Ref = MustCreateRef(url)
+	return resp
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/responses.go

@@ -0,0 +1,110 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"reflect"
+	"strconv"
+
+	"github.com/go-openapi/swag"
+)
+
+// Responses is a container for the expected responses of an operation.
+// The container maps a HTTP response code to the expected response.
+// It is not expected from the documentation to necessarily cover all possible HTTP response codes,
+// since they may not be known in advance. However, it is expected from the documentation to cover
+// a successful operation response and any known errors.
+//
+// The `default` can be used a default response object for all HTTP codes that are not covered
+// individually by the specification.
+//
+// The `Responses Object` MUST contain at least one response code, and it SHOULD be the response
+// for a successful operation call.
+//
+// For more information: http://goo.gl/8us55a#responsesObject
+type Responses struct {
+	VendorExtensible
+	ResponsesProps
+}
+
+// UnmarshalJSON hydrates this items instance with the data from JSON
+func (r *Responses) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &r.ResponsesProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &r.VendorExtensible); err != nil {
+		return err
+	}
+	if reflect.DeepEqual(ResponsesProps{}, r.ResponsesProps) {
+		r.ResponsesProps = ResponsesProps{}
+	}
+	return nil
+}
+
+// MarshalJSON converts this items object to JSON
+func (r Responses) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(r.ResponsesProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(r.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	concated := swag.ConcatJSON(b1, b2)
+	return concated, nil
+}
+
+// ResponsesProps describes all responses for an operation.
+// It tells what is the default response and maps all responses with a
+// HTTP status code.
+type ResponsesProps struct {
+	Default             *Response
+	StatusCodeResponses map[int]Response
+}
+
+// MarshalJSON marshals responses as JSON
+func (r ResponsesProps) MarshalJSON() ([]byte, error) {
+	toser := map[string]Response{}
+	if r.Default != nil {
+		toser["default"] = *r.Default
+	}
+	for k, v := range r.StatusCodeResponses {
+		toser[strconv.Itoa(k)] = v
+	}
+	return json.Marshal(toser)
+}
+
+// UnmarshalJSON unmarshals responses from JSON
+func (r *ResponsesProps) UnmarshalJSON(data []byte) error {
+	var res map[string]Response
+	if err := json.Unmarshal(data, &res); err != nil {
+		return nil
+	}
+	if v, ok := res["default"]; ok {
+		r.Default = &v
+		delete(res, "default")
+	}
+	for k, v := range res {
+		if nk, err := strconv.Atoi(k); err == nil {
+			if r.StatusCodeResponses == nil {
+				r.StatusCodeResponses = map[int]Response{}
+			}
+			r.StatusCodeResponses[nk] = v
+		}
+	}
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/schema.go

@@ -0,0 +1,513 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/go-openapi/swag"
+)
+
+// BooleanProperty creates a boolean property
+func BooleanProperty() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"boolean"}}}
+}
+
+// BoolProperty creates a boolean property
+func BoolProperty() *Schema { return BooleanProperty() }
+
+// StringProperty creates a string property
+func StringProperty() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
+}
+
+// CharProperty creates a string property
+func CharProperty() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
+}
+
+// Float64Property creates a float64/double property
+func Float64Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "double"}}
+}
+
+// Float32Property creates a float32/float property
+func Float32Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "float"}}
+}
+
+// Int8Property creates an int8 property
+func Int8Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int8"}}
+}
+
+// Int16Property creates an int16 property
+func Int16Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int16"}}
+}
+
+// Int32Property creates an int32 property
+func Int32Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int32"}}
+}
+
+// Int64Property creates an int64 property
+func Int64Property() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}}
+}
+
+// StrFmtProperty creates a property for the named string format
+func StrFmtProperty(format string) *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: format}}
+}
+
+// DateProperty creates a date property
+func DateProperty() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date"}}
+}
+
+// DateTimeProperty creates a date time property
+func DateTimeProperty() *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date-time"}}
+}
+
+// MapProperty creates a map property
+func MapProperty(property *Schema) *Schema {
+	return &Schema{SchemaProps: SchemaProps{Type: []string{"object"},
+		AdditionalProperties: &SchemaOrBool{Allows: true, Schema: property}}}
+}
+
+// RefProperty creates a ref property
+func RefProperty(name string) *Schema {
+	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
+}
+
+// RefSchema creates a ref property
+func RefSchema(name string) *Schema {
+	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
+}
+
+// ArrayProperty creates an array property
+func ArrayProperty(items *Schema) *Schema {
+	if items == nil {
+		return &Schema{SchemaProps: SchemaProps{Type: []string{"array"}}}
+	}
+	return &Schema{SchemaProps: SchemaProps{Items: &SchemaOrArray{Schema: items}, Type: []string{"array"}}}
+}
+
+// ComposedSchema creates a schema with allOf
+func ComposedSchema(schemas ...Schema) *Schema {
+	s := new(Schema)
+	s.AllOf = schemas
+	return s
+}
+
+// SchemaURL represents a schema url
+type SchemaURL string
+
+// MarshalJSON marshal this to JSON
+func (r SchemaURL) MarshalJSON() ([]byte, error) {
+	if r == "" {
+		return []byte("{}"), nil
+	}
+	v := map[string]interface{}{"$schema": string(r)}
+	return json.Marshal(v)
+}
+
+// UnmarshalJSON unmarshal this from JSON
+func (r *SchemaURL) UnmarshalJSON(data []byte) error {
+	var v map[string]interface{}
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	return r.fromMap(v)
+}
+
+func (r *SchemaURL) fromMap(v map[string]interface{}) error {
+	if v == nil {
+		return nil
+	}
+	if vv, ok := v["$schema"]; ok {
+		if str, ok := vv.(string); ok {
+			u, err := url.Parse(str)
+			if err != nil {
+				return err
+			}
+
+			*r = SchemaURL(u.String())
+		}
+	}
+	return nil
+}
+
+// SchemaProps describes a JSON schema (draft 4)
+type SchemaProps struct {
+	ID                   string            `json:"id,omitempty"`
+	Ref                  Ref               `json:"-"`
+	Schema               SchemaURL         `json:"-"`
+	Description          string            `json:"description,omitempty"`
+	Type                 StringOrArray     `json:"type,omitempty"`
+	Nullable             bool              `json:"nullable,omitempty"`
+	Format               string            `json:"format,omitempty"`
+	Title                string            `json:"title,omitempty"`
+	Default              interface{}       `json:"default,omitempty"`
+	Maximum              *float64          `json:"maximum,omitempty"`
+	ExclusiveMaximum     bool              `json:"exclusiveMaximum,omitempty"`
+	Minimum              *float64          `json:"minimum,omitempty"`
+	ExclusiveMinimum     bool              `json:"exclusiveMinimum,omitempty"`
+	MaxLength            *int64            `json:"maxLength,omitempty"`
+	MinLength            *int64            `json:"minLength,omitempty"`
+	Pattern              string            `json:"pattern,omitempty"`
+	MaxItems             *int64            `json:"maxItems,omitempty"`
+	MinItems             *int64            `json:"minItems,omitempty"`
+	UniqueItems          bool              `json:"uniqueItems,omitempty"`
+	MultipleOf           *float64          `json:"multipleOf,omitempty"`
+	Enum                 []interface{}     `json:"enum,omitempty"`
+	MaxProperties        *int64            `json:"maxProperties,omitempty"`
+	MinProperties        *int64            `json:"minProperties,omitempty"`
+	Required             []string          `json:"required,omitempty"`
+	Items                *SchemaOrArray    `json:"items,omitempty"`
+	AllOf                []Schema          `json:"allOf,omitempty"`
+	OneOf                []Schema          `json:"oneOf,omitempty"`
+	AnyOf                []Schema          `json:"anyOf,omitempty"`
+	Not                  *Schema           `json:"not,omitempty"`
+	Properties           map[string]Schema `json:"properties,omitempty"`
+	AdditionalProperties *SchemaOrBool     `json:"additionalProperties,omitempty"`
+	PatternProperties    map[string]Schema `json:"patternProperties,omitempty"`
+	Dependencies         Dependencies      `json:"dependencies,omitempty"`
+	AdditionalItems      *SchemaOrBool     `json:"additionalItems,omitempty"`
+	Definitions          Definitions       `json:"definitions,omitempty"`
+}
+
+// SwaggerSchemaProps are additional properties supported by swagger schemas, but not JSON-schema (draft 4)
+type SwaggerSchemaProps struct {
+	Discriminator string                 `json:"discriminator,omitempty"`
+	ReadOnly      bool                   `json:"readOnly,omitempty"`
+	ExternalDocs  *ExternalDocumentation `json:"externalDocs,omitempty"`
+	Example       interface{}            `json:"example,omitempty"`
+}
+
+// Schema the schema object allows the definition of input and output data types.
+// These types can be objects, but also primitives and arrays.
+// This object is based on the [JSON Schema Specification Draft 4](http://json-schema.org/)
+// and uses a predefined subset of it.
+// On top of this subset, there are extensions provided by this specification to allow for more complete documentation.
+//
+// For more information: http://goo.gl/8us55a#schemaObject
+type Schema struct {
+	VendorExtensible
+	SchemaProps
+	SwaggerSchemaProps
+	ExtraProps map[string]interface{} `json:"-"`
+}
+
+// WithID sets the id for this schema, allows for chaining
+func (s *Schema) WithID(id string) *Schema {
+	s.ID = id
+	return s
+}
+
+// WithTitle sets the title for this schema, allows for chaining
+func (s *Schema) WithTitle(title string) *Schema {
+	s.Title = title
+	return s
+}
+
+// WithDescription sets the description for this schema, allows for chaining
+func (s *Schema) WithDescription(description string) *Schema {
+	s.Description = description
+	return s
+}
+
+// WithProperties sets the properties for this schema
+func (s *Schema) WithProperties(schemas map[string]Schema) *Schema {
+	s.Properties = schemas
+	return s
+}
+
+// SetProperty sets a property on this schema
+func (s *Schema) SetProperty(name string, schema Schema) *Schema {
+	if s.Properties == nil {
+		s.Properties = make(map[string]Schema)
+	}
+	s.Properties[name] = schema
+	return s
+}
+
+// WithAllOf sets the all of property
+func (s *Schema) WithAllOf(schemas ...Schema) *Schema {
+	s.AllOf = schemas
+	return s
+}
+
+// WithMaxProperties sets the max number of properties an object can have
+func (s *Schema) WithMaxProperties(max int64) *Schema {
+	s.MaxProperties = &max
+	return s
+}
+
+// WithMinProperties sets the min number of properties an object must have
+func (s *Schema) WithMinProperties(min int64) *Schema {
+	s.MinProperties = &min
+	return s
+}
+
+// Typed sets the type of this schema for a single value item
+func (s *Schema) Typed(tpe, format string) *Schema {
+	s.Type = []string{tpe}
+	s.Format = format
+	return s
+}
+
+// AddType adds a type with potential format to the types for this schema
+func (s *Schema) AddType(tpe, format string) *Schema {
+	s.Type = append(s.Type, tpe)
+	if format != "" {
+		s.Format = format
+	}
+	return s
+}
+
+// AsNullable flags this schema as nullable.
+func (s *Schema) AsNullable() *Schema {
+	s.Nullable = true
+	return s
+}
+
+// CollectionOf a fluent builder method for an array parameter
+func (s *Schema) CollectionOf(items Schema) *Schema {
+	s.Type = []string{jsonArray}
+	s.Items = &SchemaOrArray{Schema: &items}
+	return s
+}
+
+// WithDefault sets the default value on this parameter
+func (s *Schema) WithDefault(defaultValue interface{}) *Schema {
+	s.Default = defaultValue
+	return s
+}
+
+// WithRequired flags this parameter as required
+func (s *Schema) WithRequired(items ...string) *Schema {
+	s.Required = items
+	return s
+}
+
+// AddRequired  adds field names to the required properties array
+func (s *Schema) AddRequired(items ...string) *Schema {
+	s.Required = append(s.Required, items...)
+	return s
+}
+
+// WithMaxLength sets a max length value
+func (s *Schema) WithMaxLength(max int64) *Schema {
+	s.MaxLength = &max
+	return s
+}
+
+// WithMinLength sets a min length value
+func (s *Schema) WithMinLength(min int64) *Schema {
+	s.MinLength = &min
+	return s
+}
+
+// WithPattern sets a pattern value
+func (s *Schema) WithPattern(pattern string) *Schema {
+	s.Pattern = pattern
+	return s
+}
+
+// WithMultipleOf sets a multiple of value
+func (s *Schema) WithMultipleOf(number float64) *Schema {
+	s.MultipleOf = &number
+	return s
+}
+
+// WithMaximum sets a maximum number value
+func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema {
+	s.Maximum = &max
+	s.ExclusiveMaximum = exclusive
+	return s
+}
+
+// WithMinimum sets a minimum number value
+func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema {
+	s.Minimum = &min
+	s.ExclusiveMinimum = exclusive
+	return s
+}
+
+// WithEnum sets a the enum values (replace)
+func (s *Schema) WithEnum(values ...interface{}) *Schema {
+	s.Enum = append([]interface{}{}, values...)
+	return s
+}
+
+// WithMaxItems sets the max items
+func (s *Schema) WithMaxItems(size int64) *Schema {
+	s.MaxItems = &size
+	return s
+}
+
+// WithMinItems sets the min items
+func (s *Schema) WithMinItems(size int64) *Schema {
+	s.MinItems = &size
+	return s
+}
+
+// UniqueValues dictates that this array can only have unique items
+func (s *Schema) UniqueValues() *Schema {
+	s.UniqueItems = true
+	return s
+}
+
+// AllowDuplicates this array can have duplicates
+func (s *Schema) AllowDuplicates() *Schema {
+	s.UniqueItems = false
+	return s
+}
+
+// AddToAllOf adds a schema to the allOf property
+func (s *Schema) AddToAllOf(schemas ...Schema) *Schema {
+	s.AllOf = append(s.AllOf, schemas...)
+	return s
+}
+
+// WithDiscriminator sets the name of the discriminator field
+func (s *Schema) WithDiscriminator(discriminator string) *Schema {
+	s.Discriminator = discriminator
+	return s
+}
+
+// AsReadOnly flags this schema as readonly
+func (s *Schema) AsReadOnly() *Schema {
+	s.ReadOnly = true
+	return s
+}
+
+// AsWritable flags this schema as writeable (not read-only)
+func (s *Schema) AsWritable() *Schema {
+	s.ReadOnly = false
+	return s
+}
+
+// WithExample sets the example for this schema
+func (s *Schema) WithExample(example interface{}) *Schema {
+	s.Example = example
+	return s
+}
+
+// WithExternalDocs sets/removes the external docs for/from this schema.
+// When you pass empty strings as params the external documents will be removed.
+// When you pass non-empty string as one value then those values will be used on the external docs object.
+// So when you pass a non-empty description, you should also pass the url and vice versa.
+func (s *Schema) WithExternalDocs(description, url string) *Schema {
+	if description == "" && url == "" {
+		s.ExternalDocs = nil
+		return s
+	}
+
+	if s.ExternalDocs == nil {
+		s.ExternalDocs = &ExternalDocumentation{}
+	}
+	s.ExternalDocs.Description = description
+	s.ExternalDocs.URL = url
+	return s
+}
+
+// MarshalJSON marshal this to JSON
+func (s Schema) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.SchemaProps)
+	if err != nil {
+		return nil, fmt.Errorf("schema props %v", err)
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, fmt.Errorf("vendor props %v", err)
+	}
+	b3, err := s.Ref.MarshalJSON()
+	if err != nil {
+		return nil, fmt.Errorf("ref prop %v", err)
+	}
+	b4, err := s.Schema.MarshalJSON()
+	if err != nil {
+		return nil, fmt.Errorf("schema prop %v", err)
+	}
+	b5, err := json.Marshal(s.SwaggerSchemaProps)
+	if err != nil {
+		return nil, fmt.Errorf("common validations %v", err)
+	}
+	var b6 []byte
+	if s.ExtraProps != nil {
+		jj, err := json.Marshal(s.ExtraProps)
+		if err != nil {
+			return nil, fmt.Errorf("extra props %v", err)
+		}
+		b6 = jj
+	}
+	return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil
+}
+
+// UnmarshalJSON marshal this from JSON
+func (s *Schema) UnmarshalJSON(data []byte) error {
+	props := struct {
+		SchemaProps
+		SwaggerSchemaProps
+	}{}
+	if err := json.Unmarshal(data, &props); err != nil {
+		return err
+	}
+
+	sch := Schema{
+		SchemaProps:        props.SchemaProps,
+		SwaggerSchemaProps: props.SwaggerSchemaProps,
+	}
+
+	var d map[string]interface{}
+	if err := json.Unmarshal(data, &d); err != nil {
+		return err
+	}
+
+	_ = sch.Ref.fromMap(d)
+	_ = sch.Schema.fromMap(d)
+
+	delete(d, "$ref")
+	delete(d, "$schema")
+	for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) {
+		delete(d, pn)
+	}
+
+	for k, vv := range d {
+		lk := strings.ToLower(k)
+		if strings.HasPrefix(lk, "x-") {
+			if sch.Extensions == nil {
+				sch.Extensions = map[string]interface{}{}
+			}
+			sch.Extensions[k] = vv
+			continue
+		}
+		if sch.ExtraProps == nil {
+			sch.ExtraProps = map[string]interface{}{}
+		}
+		sch.ExtraProps[k] = vv
+	}
+
+	*s = sch
+
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/security_scheme.go

@@ -0,0 +1,64 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// SecuritySchemeProps describes a swagger security scheme in the securityDefinitions section
+type SecuritySchemeProps struct {
+	Description      string            `json:"description,omitempty"`
+	Type             string            `json:"type"`
+	Name             string            `json:"name,omitempty"`             // api key
+	In               string            `json:"in,omitempty"`               // api key
+	Flow             string            `json:"flow,omitempty"`             // oauth2
+	AuthorizationURL string            `json:"authorizationUrl,omitempty"` // oauth2
+	TokenURL         string            `json:"tokenUrl,omitempty"`         // oauth2
+	Scopes           map[string]string `json:"scopes,omitempty"`           // oauth2
+}
+
+// SecurityScheme allows the definition of a security scheme that can be used by the operations.
+// Supported schemes are basic authentication, an API key (either as a header or as a query parameter)
+// and OAuth2's common flows (implicit, password, application and access code).
+//
+// For more information: http://goo.gl/8us55a#securitySchemeObject
+type SecurityScheme struct {
+	VendorExtensible
+	SecuritySchemeProps
+}
+
+// MarshalJSON marshal this to JSON
+func (s SecurityScheme) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.SecuritySchemeProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON marshal this from JSON
+func (s *SecurityScheme) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &s.VendorExtensible)
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/swagger.go

@@ -0,0 +1,286 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/go-openapi/swag"
+)
+
+// Swagger this is the root document object for the API specification.
+// It combines what previously was the Resource Listing and API Declaration (version 1.2 and earlier)
+// together into one document.
+//
+// For more information: http://goo.gl/8us55a#swagger-object-
+type Swagger struct {
+	VendorExtensible
+	SwaggerProps
+}
+
+// MarshalJSON marshals this swagger structure to json
+func (s Swagger) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(s.SwaggerProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(s.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON unmarshals a swagger spec from json
+func (s *Swagger) UnmarshalJSON(data []byte) error {
+	var sw Swagger
+	if err := json.Unmarshal(data, &sw.SwaggerProps); err != nil {
+		return err
+	}
+	if err := json.Unmarshal(data, &sw.VendorExtensible); err != nil {
+		return err
+	}
+	*s = sw
+	return nil
+}
+
+// SwaggerProps captures the top-level properties of an Api specification
+//
+// NOTE: validation rules
+// - the scheme, when present must be from [http, https, ws, wss]
+// - BasePath must start with a leading "/"
+// - Paths is required
+type SwaggerProps struct {
+	ID                  string                 `json:"id,omitempty"`
+	Consumes            []string               `json:"consumes,omitempty"`
+	Produces            []string               `json:"produces,omitempty"`
+	Schemes             []string               `json:"schemes,omitempty"`
+	Swagger             string                 `json:"swagger,omitempty"`
+	Info                *Info                  `json:"info,omitempty"`
+	Host                string                 `json:"host,omitempty"`
+	BasePath            string                 `json:"basePath,omitempty"`
+	Paths               *Paths                 `json:"paths"`
+	Definitions         Definitions            `json:"definitions,omitempty"`
+	Parameters          map[string]Parameter   `json:"parameters,omitempty"`
+	Responses           map[string]Response    `json:"responses,omitempty"`
+	SecurityDefinitions SecurityDefinitions    `json:"securityDefinitions,omitempty"`
+	Security            []map[string][]string  `json:"security,omitempty"`
+	Tags                []Tag                  `json:"tags,omitempty"`
+	ExternalDocs        *ExternalDocumentation `json:"externalDocs,omitempty"`
+}
+
+// Dependencies represent a dependencies property
+type Dependencies map[string]SchemaOrStringArray
+
+// SchemaOrBool represents a schema or boolean value, is biased towards true for the boolean property
+type SchemaOrBool struct {
+	Allows bool
+	Schema *Schema
+}
+
+var jsTrue = []byte("true")
+var jsFalse = []byte("false")
+
+// MarshalJSON convert this object to JSON
+func (s SchemaOrBool) MarshalJSON() ([]byte, error) {
+	if s.Schema != nil {
+		return json.Marshal(s.Schema)
+	}
+
+	if s.Schema == nil && !s.Allows {
+		return jsFalse, nil
+	}
+	return jsTrue, nil
+}
+
+// UnmarshalJSON converts this bool or schema object from a JSON structure
+func (s *SchemaOrBool) UnmarshalJSON(data []byte) error {
+	var nw SchemaOrBool
+	if len(data) >= 4 {
+		if data[0] == '{' {
+			var sch Schema
+			if err := json.Unmarshal(data, &sch); err != nil {
+				return err
+			}
+			nw.Schema = &sch
+		}
+		nw.Allows = !(data[0] == 'f' && data[1] == 'a' && data[2] == 'l' && data[3] == 's' && data[4] == 'e')
+	}
+	*s = nw
+	return nil
+}
+
+// SchemaOrStringArray represents a schema or a string array
+type SchemaOrStringArray struct {
+	Schema   *Schema
+	Property []string
+}
+
+// MarshalJSON converts this schema object or array into JSON structure
+func (s SchemaOrStringArray) MarshalJSON() ([]byte, error) {
+	if len(s.Property) > 0 {
+		return json.Marshal(s.Property)
+	}
+	if s.Schema != nil {
+		return json.Marshal(s.Schema)
+	}
+	return []byte("null"), nil
+}
+
+// UnmarshalJSON converts this schema object or array from a JSON structure
+func (s *SchemaOrStringArray) UnmarshalJSON(data []byte) error {
+	var first byte
+	if len(data) > 1 {
+		first = data[0]
+	}
+	var nw SchemaOrStringArray
+	if first == '{' {
+		var sch Schema
+		if err := json.Unmarshal(data, &sch); err != nil {
+			return err
+		}
+		nw.Schema = &sch
+	}
+	if first == '[' {
+		if err := json.Unmarshal(data, &nw.Property); err != nil {
+			return err
+		}
+	}
+	*s = nw
+	return nil
+}
+
+// Definitions contains the models explicitly defined in this spec
+// An object to hold data types that can be consumed and produced by operations.
+// These data types can be primitives, arrays or models.
+//
+// For more information: http://goo.gl/8us55a#definitionsObject
+type Definitions map[string]Schema
+
+// SecurityDefinitions a declaration of the security schemes available to be used in the specification.
+// This does not enforce the security schemes on the operations and only serves to provide
+// the relevant details for each scheme.
+//
+// For more information: http://goo.gl/8us55a#securityDefinitionsObject
+type SecurityDefinitions map[string]*SecurityScheme
+
+// StringOrArray represents a value that can either be a string
+// or an array of strings. Mainly here for serialization purposes
+type StringOrArray []string
+
+// Contains returns true when the value is contained in the slice
+func (s StringOrArray) Contains(value string) bool {
+	for _, str := range s {
+		if str == value {
+			return true
+		}
+	}
+	return false
+}
+
+// UnmarshalJSON unmarshals this string or array object from a JSON array or JSON string
+func (s *StringOrArray) UnmarshalJSON(data []byte) error {
+	var first byte
+	if len(data) > 1 {
+		first = data[0]
+	}
+
+	if first == '[' {
+		var parsed []string
+		if err := json.Unmarshal(data, &parsed); err != nil {
+			return err
+		}
+		*s = StringOrArray(parsed)
+		return nil
+	}
+
+	var single interface{}
+	if err := json.Unmarshal(data, &single); err != nil {
+		return err
+	}
+	if single == nil {
+		return nil
+	}
+	switch v := single.(type) {
+	case string:
+		*s = StringOrArray([]string{v})
+		return nil
+	default:
+		return fmt.Errorf("only string or array is allowed, not %T", single)
+	}
+}
+
+// MarshalJSON converts this string or array to a JSON array or JSON string
+func (s StringOrArray) MarshalJSON() ([]byte, error) {
+	if len(s) == 1 {
+		return json.Marshal([]string(s)[0])
+	}
+	return json.Marshal([]string(s))
+}
+
+// SchemaOrArray represents a value that can either be a Schema
+// or an array of Schema. Mainly here for serialization purposes
+type SchemaOrArray struct {
+	Schema  *Schema
+	Schemas []Schema
+}
+
+// Len returns the number of schemas in this property
+func (s SchemaOrArray) Len() int {
+	if s.Schema != nil {
+		return 1
+	}
+	return len(s.Schemas)
+}
+
+// ContainsType returns true when one of the schemas is of the specified type
+func (s *SchemaOrArray) ContainsType(name string) bool {
+	if s.Schema != nil {
+		return s.Schema.Type != nil && s.Schema.Type.Contains(name)
+	}
+	return false
+}
+
+// MarshalJSON converts this schema object or array into JSON structure
+func (s SchemaOrArray) MarshalJSON() ([]byte, error) {
+	if len(s.Schemas) > 0 {
+		return json.Marshal(s.Schemas)
+	}
+	return json.Marshal(s.Schema)
+}
+
+// UnmarshalJSON converts this schema object or array from a JSON structure
+func (s *SchemaOrArray) UnmarshalJSON(data []byte) error {
+	var nw SchemaOrArray
+	var first byte
+	if len(data) > 1 {
+		first = data[0]
+	}
+	if first == '{' {
+		var sch Schema
+		if err := json.Unmarshal(data, &sch); err != nil {
+			return err
+		}
+		nw.Schema = &sch
+	}
+	if first == '[' {
+		if err := json.Unmarshal(data, &nw.Schemas); err != nil {
+			return err
+		}
+	}
+	*s = nw
+	return nil
+}

vendor/k8s.io/kube-openapi/pkg/validation/spec/tag.go

@@ -0,0 +1,59 @@
+// Copyright 2015 go-swagger maintainers
+//
+// 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 spec
+
+import (
+	"encoding/json"
+
+	"github.com/go-openapi/swag"
+)
+
+// TagProps describe a tag entry in the top level tags section of a swagger spec
+type TagProps struct {
+	Description  string                 `json:"description,omitempty"`
+	Name         string                 `json:"name,omitempty"`
+	ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
+}
+
+// Tag allows adding meta data to a single tag that is used by the
+// [Operation Object](http://goo.gl/8us55a#operationObject).
+// It is not mandatory to have a Tag Object per tag used there.
+//
+// For more information: http://goo.gl/8us55a#tagObject
+type Tag struct {
+	VendorExtensible
+	TagProps
+}
+
+// MarshalJSON marshal this to JSON
+func (t Tag) MarshalJSON() ([]byte, error) {
+	b1, err := json.Marshal(t.TagProps)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := json.Marshal(t.VendorExtensible)
+	if err != nil {
+		return nil, err
+	}
+	return swag.ConcatJSON(b1, b2), nil
+}
+
+// UnmarshalJSON marshal this from JSON
+func (t *Tag) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &t.TagProps); err != nil {
+		return err
+	}
+	return json.Unmarshal(data, &t.VendorExtensible)
+}