Upgrade k8s package verison (#5358)

* upgrade k8s package version

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

* Script upgrade and code formatting.

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

Signed-off-by: hongzhouzi <hongzhouzi@kubesphere.io>

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

@@ -22,11 +22,12 @@ import (
 	"net/http"
 	"strings"
 
-	restful "github.com/emicklei/go-restful"
-	"github.com/go-openapi/spec"
+	restful "github.com/emicklei/go-restful/v3"
 
 	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/common/restfuladapter"
 	"k8s.io/kube-openapi/pkg/util"
+	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
 const (
@@ -40,10 +41,17 @@ type openAPI struct {
 	definitions  map[string]common.OpenAPIDefinition
 }
 
-// BuildOpenAPISpec builds OpenAPI spec given a list of webservices (containing routes) and common.Config to customize it.
-func BuildOpenAPISpec(webServices []*restful.WebService, config *common.Config) (*spec.Swagger, error) {
+// BuildOpenAPISpec builds OpenAPI spec given a list of route containers and common.Config to customize it.
+//
+// Deprecated: BuildOpenAPISpecFromRoutes should be used instead.
+func BuildOpenAPISpec(routeContainers []*restful.WebService, config *common.Config) (*spec.Swagger, error) {
+	return BuildOpenAPISpecFromRoutes(restfuladapter.AdaptWebServices(routeContainers), config)
+}
+
+// BuildOpenAPISpecFromRoutes builds OpenAPI spec given a list of route containers and common.Config to customize it.
+func BuildOpenAPISpecFromRoutes(routeContainers []common.RouteContainer, config *common.Config) (*spec.Swagger, error) {
 	o := newOpenAPI(config)
-	err := o.buildPaths(webServices)
+	err := o.buildPaths(routeContainers)
 	if err != nil {
 		return nil, err
 	}
@@ -95,11 +103,25 @@ func newOpenAPI(config *common.Config) openAPI {
 			},
 		},
 	}
-	if o.config.GetOperationIDAndTags == nil {
-		o.config.GetOperationIDAndTags = func(r *restful.Route) (string, []string, error) {
-			return r.Operation, nil, nil
+
+	if o.config.GetOperationIDAndTagsFromRoute == nil {
+		// Map the deprecated handler to the common interface, if provided.
+		if o.config.GetOperationIDAndTags != nil {
+			o.config.GetOperationIDAndTagsFromRoute = func(r common.Route) (string, []string, error) {
+				restfulRouteAdapter, ok := r.(*restfuladapter.RouteAdapter)
+				if !ok {
+					return "", nil, fmt.Errorf("config.GetOperationIDAndTags specified but route is not a restful v1 Route")
+				}
+
+				return o.config.GetOperationIDAndTags(restfulRouteAdapter.Route)
+			}
+		} else {
+			o.config.GetOperationIDAndTagsFromRoute = func(r common.Route) (string, []string, error) {
+				return r.OperationName(), nil, nil
+			}
 		}
 	}
+
 	if o.config.GetDefinitionName == nil {
 		o.config.GetDefinitionName = func(name string) (string, spec.Extensions) {
 			return name[strings.LastIndex(name, "/")+1:], nil
@@ -181,10 +203,10 @@ func (o *openAPI) buildDefinitionForType(name string) (string, error) {
 }
 
 // buildPaths builds OpenAPI paths using go-restful's web services.
-func (o *openAPI) buildPaths(webServices []*restful.WebService) error {
+func (o *openAPI) buildPaths(routeContainers []common.RouteContainer) error {
 	pathsToIgnore := util.NewTrie(o.config.IgnorePrefixes)
 	duplicateOpId := make(map[string]string)
-	for _, w := range webServices {
+	for _, w := range routeContainers {
 		rootPath := w.RootPath()
 		if pathsToIgnore.HasPrefix(rootPath) {
 			continue
@@ -234,7 +256,7 @@ func (o *openAPI) buildPaths(webServices []*restful.WebService) error {
 				} else {
 					duplicateOpId[op.ID] = path
 				}
-				switch strings.ToUpper(route.Method) {
+				switch strings.ToUpper(route.Method()) {
 				case "GET":
 					pathItem.Get = op
 				case "POST":
@@ -258,12 +280,12 @@ func (o *openAPI) buildPaths(webServices []*restful.WebService) error {
 }
 
 // buildOperations builds operations for each webservice path
-func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map[interface{}]spec.Parameter) (ret *spec.Operation, err error) {
+func (o *openAPI) buildOperations(route common.Route, inPathCommonParamsMap map[interface{}]spec.Parameter) (ret *spec.Operation, err error) {
 	ret = &spec.Operation{
 		OperationProps: spec.OperationProps{
-			Description: route.Doc,
-			Consumes:    route.Consumes,
-			Produces:    route.Produces,
+			Description: route.Description(),
+			Consumes:    route.Consumes(),
+			Produces:    route.Produces(),
 			Schemes:     o.config.ProtocolList,
 			Responses: &spec.Responses{
 				ResponsesProps: spec.ResponsesProps{
@@ -272,7 +294,7 @@ func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map
 			},
 		},
 	}
-	for k, v := range route.Metadata {
+	for k, v := range route.Metadata() {
 		if strings.HasPrefix(k, common.ExtensionPrefix) {
 			if ret.Extensions == nil {
 				ret.Extensions = spec.Extensions{}
@@ -280,20 +302,20 @@ func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map
 			ret.Extensions.Add(k, v)
 		}
 	}
-	if ret.ID, ret.Tags, err = o.config.GetOperationIDAndTags(&route); err != nil {
+	if ret.ID, ret.Tags, err = o.config.GetOperationIDAndTagsFromRoute(route); err != nil {
 		return ret, err
 	}
 
 	// Build responses
-	for _, resp := range route.ResponseErrors {
-		ret.Responses.StatusCodeResponses[resp.Code], err = o.buildResponse(resp.Model, resp.Message)
+	for _, resp := range route.StatusCodeResponses() {
+		ret.Responses.StatusCodeResponses[resp.Code()], err = o.buildResponse(resp.Model(), resp.Message())
 		if err != nil {
 			return ret, err
 		}
 	}
 	// If there is no response but a write sample, assume that write sample is an http.StatusOK response.
-	if len(ret.Responses.StatusCodeResponses) == 0 && route.WriteSample != nil {
-		ret.Responses.StatusCodeResponses[http.StatusOK], err = o.buildResponse(route.WriteSample, "OK")
+	if len(ret.Responses.StatusCodeResponses) == 0 && route.ResponsePayloadSample() != nil {
+		ret.Responses.StatusCodeResponses[http.StatusOK], err = o.buildResponse(route.ResponsePayloadSample(), "OK")
 		if err != nil {
 			return ret, err
 		}
@@ -310,9 +332,9 @@ func (o *openAPI) buildOperations(route restful.Route, inPathCommonParamsMap map
 
 	// Build non-common Parameters
 	ret.Parameters = make([]spec.Parameter, 0)
-	for _, param := range route.ParameterDocs {
+	for _, param := range route.Parameters() {
 		if _, isCommon := inPathCommonParamsMap[mapKeyFromParam(param)]; !isCommon {
-			openAPIParam, err := o.buildParameter(param.Data(), route.ReadSample)
+			openAPIParam, err := o.buildParameter(param, route.RequestPayloadSample())
 			if err != nil {
 				return ret, err
 			}
@@ -335,29 +357,30 @@ func (o *openAPI) buildResponse(model interface{}, description string) (spec.Res
 	}, nil
 }
 
-func (o *openAPI) findCommonParameters(routes []restful.Route) (map[interface{}]spec.Parameter, error) {
+func (o *openAPI) findCommonParameters(routes []common.Route) (map[interface{}]spec.Parameter, error) {
 	commonParamsMap := make(map[interface{}]spec.Parameter, 0)
 	paramOpsCountByName := make(map[interface{}]int, 0)
-	paramNameKindToDataMap := make(map[interface{}]restful.ParameterData, 0)
+	paramNameKindToDataMap := make(map[interface{}]common.Parameter, 0)
 	for _, route := range routes {
 		routeParamDuplicateMap := make(map[interface{}]bool)
 		s := ""
-		for _, param := range route.ParameterDocs {
-			m, _ := json.Marshal(param.Data())
+		params := route.Parameters()
+		for _, param := range params {
+			m, _ := json.Marshal(param)
 			s += string(m) + "\n"
 			key := mapKeyFromParam(param)
 			if routeParamDuplicateMap[key] {
-				msg, _ := json.Marshal(route.ParameterDocs)
-				return commonParamsMap, fmt.Errorf("duplicate parameter %v for route %v, %v", param.Data().Name, string(msg), s)
+				msg, _ := json.Marshal(params)
+				return commonParamsMap, fmt.Errorf("duplicate parameter %v for route %v, %v", param.Name(), string(msg), s)
 			}
 			routeParamDuplicateMap[key] = true
 			paramOpsCountByName[key]++
-			paramNameKindToDataMap[key] = param.Data()
+			paramNameKindToDataMap[key] = param
 		}
 	}
 	for key, count := range paramOpsCountByName {
 		paramData := paramNameKindToDataMap[key]
-		if count == len(routes) && paramData.Kind != restful.BodyParameterKind {
+		if count == len(routes) && paramData.Kind() != common.BodyParameterKind {
 			openAPIParam, err := o.buildParameter(paramData, nil)
 			if err != nil {
 				return commonParamsMap, err
@@ -389,16 +412,16 @@ func (o *openAPI) toSchema(name string) (_ *spec.Schema, err error) {
 	}
 }
 
-func (o *openAPI) buildParameter(restParam restful.ParameterData, bodySample interface{}) (ret spec.Parameter, err error) {
+func (o *openAPI) buildParameter(restParam common.Parameter, bodySample interface{}) (ret spec.Parameter, err error) {
 	ret = spec.Parameter{
 		ParamProps: spec.ParamProps{
-			Name:        restParam.Name,
-			Description: restParam.Description,
-			Required:    restParam.Required,
+			Name:        restParam.Name(),
+			Description: restParam.Description(),
+			Required:    restParam.Required(),
 		},
 	}
-	switch restParam.Kind {
-	case restful.BodyParameterKind:
+	switch restParam.Kind() {
+	case common.BodyParameterKind:
 		if bodySample != nil {
 			ret.In = "body"
 			ret.Schema, err = o.toSchema(util.GetCanonicalTypeName(bodySample))
@@ -407,36 +430,36 @@ func (o *openAPI) buildParameter(restParam restful.ParameterData, bodySample int
 			// There is not enough information in the body parameter to build the definition.
 			// Body parameter has a data type that is a short name but we need full package name
 			// of the type to create a definition.
-			return ret, fmt.Errorf("restful body parameters are not supported: %v", restParam.DataType)
+			return ret, fmt.Errorf("restful body parameters are not supported: %v", restParam.DataType())
 		}
-	case restful.PathParameterKind:
+	case common.PathParameterKind:
 		ret.In = "path"
-		if !restParam.Required {
+		if !restParam.Required() {
 			return ret, fmt.Errorf("path parameters should be marked at required for parameter %v", restParam)
 		}
-	case restful.QueryParameterKind:
+	case common.QueryParameterKind:
 		ret.In = "query"
-	case restful.HeaderParameterKind:
+	case common.HeaderParameterKind:
 		ret.In = "header"
-	case restful.FormParameterKind:
+	case common.FormParameterKind:
 		ret.In = "formData"
 	default:
-		return ret, fmt.Errorf("unknown restful operation kind : %v", restParam.Kind)
+		return ret, fmt.Errorf("unknown restful operation kind : %v", restParam.Kind())
 	}
-	openAPIType, openAPIFormat := common.OpenAPITypeFormat(restParam.DataType)
+	openAPIType, openAPIFormat := common.OpenAPITypeFormat(restParam.DataType())
 	if openAPIType == "" {
-		return ret, fmt.Errorf("non-body Restful parameter type should be a simple type, but got : %v", restParam.DataType)
+		return ret, fmt.Errorf("non-body Restful parameter type should be a simple type, but got : %v", restParam.DataType())
 	}
 	ret.Type = openAPIType
 	ret.Format = openAPIFormat
-	ret.UniqueItems = !restParam.AllowMultiple
+	ret.UniqueItems = !restParam.AllowMultiple()
 	return ret, nil
 }
 
-func (o *openAPI) buildParameters(restParam []*restful.Parameter) (ret []spec.Parameter, err error) {
+func (o *openAPI) buildParameters(restParam []common.Parameter) (ret []spec.Parameter, err error) {
 	ret = make([]spec.Parameter, len(restParam))
 	for i, v := range restParam {
-		ret[i], err = o.buildParameter(v.Data(), nil)
+		ret[i], err = o.buildParameter(v, nil)
 		if err != nil {
 			return ret, err
 		}

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

@@ -19,8 +19,8 @@ package builder
 import (
 	"sort"
 
-	"github.com/emicklei/go-restful"
-	"github.com/go-openapi/spec"
+	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
 type parameters []spec.Parameter
@@ -42,20 +42,20 @@ func sortParameters(p []spec.Parameter) {
 	sort.Sort(byNameIn{p})
 }
 
-func groupRoutesByPath(routes []restful.Route) map[string][]restful.Route {
-	pathToRoutes := make(map[string][]restful.Route)
+func groupRoutesByPath(routes []common.Route) map[string][]common.Route {
+	pathToRoutes := make(map[string][]common.Route)
 	for _, r := range routes {
-		pathToRoutes[r.Path] = append(pathToRoutes[r.Path], r)
+		pathToRoutes[r.Path()] = append(pathToRoutes[r.Path()], r)
 	}
 	return pathToRoutes
 }
 
-func mapKeyFromParam(param *restful.Parameter) interface{} {
+func mapKeyFromParam(param common.Parameter) interface{} {
 	return struct {
 		Name string
-		Kind int
+		Kind common.ParameterKind
 	}{
-		Name: param.Data().Name,
-		Kind: param.Data().Kind,
+		Name: param.Name(),
+		Kind: param.Kind(),
 	}
 }

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

@@ -0,0 +1,475 @@
+/*
+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 builder3
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+
+	restful "github.com/emicklei/go-restful/v3"
+
+	builderutil "k8s.io/kube-openapi/pkg/builder3/util"
+	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/common/restfuladapter"
+	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/util"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+const (
+	OpenAPIVersion = "3.0"
+)
+
+type openAPI struct {
+	config      *common.OpenAPIV3Config
+	spec        *spec3.OpenAPI
+	definitions map[string]common.OpenAPIDefinition
+}
+
+func groupRoutesByPath(routes []common.Route) map[string][]common.Route {
+	pathToRoutes := make(map[string][]common.Route)
+	for _, r := range routes {
+		pathToRoutes[r.Path()] = append(pathToRoutes[r.Path()], r)
+	}
+	return pathToRoutes
+}
+
+func (o *openAPI) buildResponse(model interface{}, description string, content []string) (*spec3.Response, error) {
+	response := &spec3.Response{
+		ResponseProps: spec3.ResponseProps{
+			Description: description,
+			Content:     make(map[string]*spec3.MediaType),
+		},
+	}
+
+	s, err := o.toSchema(util.GetCanonicalTypeName(model))
+	if err != nil {
+		return nil, err
+	}
+
+	for _, contentType := range content {
+		response.ResponseProps.Content[contentType] = &spec3.MediaType{
+			MediaTypeProps: spec3.MediaTypeProps{
+				Schema: s,
+			},
+		}
+	}
+	return response, nil
+}
+
+func (o *openAPI) buildOperations(route common.Route, inPathCommonParamsMap map[interface{}]*spec3.Parameter) (*spec3.Operation, error) {
+	ret := &spec3.Operation{
+		OperationProps: spec3.OperationProps{
+			Description: route.Description(),
+			Responses: &spec3.Responses{
+				ResponsesProps: spec3.ResponsesProps{
+					StatusCodeResponses: make(map[int]*spec3.Response),
+				},
+			},
+		},
+	}
+	for k, v := range route.Metadata() {
+		if strings.HasPrefix(k, common.ExtensionPrefix) {
+			if ret.Extensions == nil {
+				ret.Extensions = spec.Extensions{}
+			}
+			ret.Extensions.Add(k, v)
+		}
+	}
+
+	var err error
+	if ret.OperationId, ret.Tags, err = o.config.GetOperationIDAndTagsFromRoute(route); err != nil {
+		return ret, err
+	}
+
+	// Build responses
+	for _, resp := range route.StatusCodeResponses() {
+		ret.Responses.StatusCodeResponses[resp.Code()], err = o.buildResponse(resp.Model(), resp.Message(), route.Produces())
+		if err != nil {
+			return ret, err
+		}
+	}
+
+	// If there is no response but a write sample, assume that write sample is an http.StatusOK response.
+	if len(ret.Responses.StatusCodeResponses) == 0 && route.ResponsePayloadSample() != nil {
+		ret.Responses.StatusCodeResponses[http.StatusOK], err = o.buildResponse(route.ResponsePayloadSample(), "OK", route.Produces())
+		if err != nil {
+			return ret, err
+		}
+	}
+
+	for code, resp := range o.config.CommonResponses {
+		if _, exists := ret.Responses.StatusCodeResponses[code]; !exists {
+			ret.Responses.StatusCodeResponses[code] = resp
+		}
+	}
+
+	if len(ret.Responses.StatusCodeResponses) == 0 {
+		ret.Responses.Default = o.config.DefaultResponse
+	}
+
+	params := route.Parameters()
+	for _, param := range params {
+		_, isCommon := inPathCommonParamsMap[mapKeyFromParam(param)]
+		if !isCommon && param.Kind() != common.BodyParameterKind {
+			openAPIParam, err := o.buildParameter(param)
+			if err != nil {
+				return ret, err
+			}
+			ret.Parameters = append(ret.Parameters, openAPIParam)
+		}
+	}
+
+	body, err := o.buildRequestBody(params, route.Consumes(), route.RequestPayloadSample())
+	if err != nil {
+		return nil, err
+	}
+
+	if body != nil {
+		ret.RequestBody = body
+	}
+	return ret, nil
+}
+
+func (o *openAPI) buildRequestBody(parameters []common.Parameter, consumes []string, bodySample interface{}) (*spec3.RequestBody, error) {
+	for _, param := range parameters {
+		if param.Kind() == common.BodyParameterKind && bodySample != nil {
+			schema, err := o.toSchema(util.GetCanonicalTypeName(bodySample))
+			if err != nil {
+				return nil, err
+			}
+			r := &spec3.RequestBody{
+				RequestBodyProps: spec3.RequestBodyProps{
+					Content: map[string]*spec3.MediaType{},
+				},
+			}
+			for _, consume := range consumes {
+				r.Content[consume] = &spec3.MediaType{
+					MediaTypeProps: spec3.MediaTypeProps{
+						Schema: schema,
+					},
+				}
+			}
+			return r, nil
+		}
+	}
+	return nil, nil
+}
+
+func newOpenAPI(config *common.Config) openAPI {
+	o := openAPI{
+		config: common.ConvertConfigToV3(config),
+		spec: &spec3.OpenAPI{
+			Version: "3.0.0",
+			Info:    config.Info,
+			Paths: &spec3.Paths{
+				Paths: map[string]*spec3.Path{},
+			},
+			Components: &spec3.Components{
+				Schemas: map[string]*spec.Schema{},
+			},
+		},
+	}
+	if len(o.config.ResponseDefinitions) > 0 {
+		o.spec.Components.Responses = make(map[string]*spec3.Response)
+
+	}
+	for k, response := range o.config.ResponseDefinitions {
+		o.spec.Components.Responses[k] = response
+	}
+
+	if len(o.config.SecuritySchemes) > 0 {
+		o.spec.Components.SecuritySchemes = make(spec3.SecuritySchemes)
+
+	}
+	for k, securityScheme := range o.config.SecuritySchemes {
+		o.spec.Components.SecuritySchemes[k] = securityScheme
+	}
+
+	if o.config.GetOperationIDAndTagsFromRoute == nil {
+		// Map the deprecated handler to the common interface, if provided.
+		if o.config.GetOperationIDAndTags != nil {
+			o.config.GetOperationIDAndTagsFromRoute = func(r common.Route) (string, []string, error) {
+				restfulRouteAdapter, ok := r.(*restfuladapter.RouteAdapter)
+				if !ok {
+					return "", nil, fmt.Errorf("config.GetOperationIDAndTags specified but route is not a restful v1 Route")
+				}
+
+				return o.config.GetOperationIDAndTags(restfulRouteAdapter.Route)
+			}
+		} else {
+			o.config.GetOperationIDAndTagsFromRoute = func(r common.Route) (string, []string, error) {
+				return r.OperationName(), nil, nil
+			}
+		}
+	}
+
+	if o.config.GetDefinitionName == nil {
+		o.config.GetDefinitionName = func(name string) (string, spec.Extensions) {
+			return name[strings.LastIndex(name, "/")+1:], nil
+		}
+	}
+
+	if o.config.Definitions != nil {
+		o.definitions = o.config.Definitions
+	} else {
+		o.definitions = o.config.GetDefinitions(func(name string) spec.Ref {
+			defName, _ := o.config.GetDefinitionName(name)
+			return spec.MustCreateRef("#/components/schemas/" + common.EscapeJsonPointer(defName))
+		})
+	}
+
+	return o
+}
+
+func (o *openAPI) buildOpenAPISpec(webServices []common.RouteContainer) error {
+	pathsToIgnore := util.NewTrie(o.config.IgnorePrefixes)
+	for _, w := range webServices {
+		rootPath := w.RootPath()
+		if pathsToIgnore.HasPrefix(rootPath) {
+			continue
+		}
+
+		commonParams, err := o.buildParameters(w.PathParameters())
+		if err != nil {
+			return err
+		}
+
+		for path, routes := range groupRoutesByPath(w.Routes()) {
+			// go-swagger has special variable definition {$NAME:*} that can only be
+			// used at the end of the path and it is not recognized by OpenAPI.
+			if strings.HasSuffix(path, ":*}") {
+				path = path[:len(path)-3] + "}"
+			}
+			if pathsToIgnore.HasPrefix(path) {
+				continue
+			}
+
+			// Aggregating common parameters make API spec (and generated clients) simpler
+			inPathCommonParamsMap, err := o.findCommonParameters(routes)
+			if err != nil {
+				return err
+			}
+			pathItem, exists := o.spec.Paths.Paths[path]
+			if exists {
+				return fmt.Errorf("duplicate webservice route has been found for path: %v", path)
+			}
+
+			pathItem = &spec3.Path{
+				PathProps: spec3.PathProps{},
+			}
+
+			// add web services's parameters as well as any parameters appears in all ops, as common parameters
+			pathItem.Parameters = append(pathItem.Parameters, commonParams...)
+			for _, p := range inPathCommonParamsMap {
+				pathItem.Parameters = append(pathItem.Parameters, p)
+			}
+			sortParameters(pathItem.Parameters)
+
+			for _, route := range routes {
+				op, _ := o.buildOperations(route, inPathCommonParamsMap)
+				sortParameters(op.Parameters)
+
+				switch strings.ToUpper(route.Method()) {
+				case "GET":
+					pathItem.Get = op
+				case "POST":
+					pathItem.Post = op
+				case "HEAD":
+					pathItem.Head = op
+				case "PUT":
+					pathItem.Put = op
+				case "DELETE":
+					pathItem.Delete = op
+				case "OPTIONS":
+					pathItem.Options = op
+				case "PATCH":
+					pathItem.Patch = op
+				}
+
+			}
+			o.spec.Paths.Paths[path] = pathItem
+		}
+	}
+	return nil
+}
+
+// BuildOpenAPISpec builds OpenAPI v3 spec given a list of route containers and common.Config to customize it.
+//
+// Deprecated: BuildOpenAPISpecFromRoutes should be used instead.
+func BuildOpenAPISpec(webServices []*restful.WebService, config *common.Config) (*spec3.OpenAPI, error) {
+	return BuildOpenAPISpecFromRoutes(restfuladapter.AdaptWebServices(webServices), config)
+}
+
+// BuildOpenAPISpecFromRoutes builds OpenAPI v3 spec given a list of route containers and common.Config to customize it.
+func BuildOpenAPISpecFromRoutes(webServices []common.RouteContainer, config *common.Config) (*spec3.OpenAPI, error) {
+	a := newOpenAPI(config)
+	err := a.buildOpenAPISpec(webServices)
+	if err != nil {
+		return nil, err
+	}
+	return a.spec, nil
+}
+
+func (o *openAPI) findCommonParameters(routes []common.Route) (map[interface{}]*spec3.Parameter, error) {
+	commonParamsMap := make(map[interface{}]*spec3.Parameter, 0)
+	paramOpsCountByName := make(map[interface{}]int, 0)
+	paramNameKindToDataMap := make(map[interface{}]common.Parameter, 0)
+	for _, route := range routes {
+		routeParamDuplicateMap := make(map[interface{}]bool)
+		s := ""
+		params := route.Parameters()
+		for _, param := range params {
+			m, _ := json.Marshal(param)
+			s += string(m) + "\n"
+			key := mapKeyFromParam(param)
+			if routeParamDuplicateMap[key] {
+				msg, _ := json.Marshal(params)
+				return commonParamsMap, fmt.Errorf("duplicate parameter %v for route %v, %v", param.Name(), string(msg), s)
+			}
+			routeParamDuplicateMap[key] = true
+			paramOpsCountByName[key]++
+			paramNameKindToDataMap[key] = param
+		}
+	}
+	for key, count := range paramOpsCountByName {
+		paramData := paramNameKindToDataMap[key]
+		if count == len(routes) && paramData.Kind() != common.BodyParameterKind {
+			openAPIParam, err := o.buildParameter(paramData)
+			if err != nil {
+				return commonParamsMap, err
+			}
+			commonParamsMap[key] = openAPIParam
+		}
+	}
+	return commonParamsMap, nil
+}
+
+func (o *openAPI) buildParameters(restParam []common.Parameter) (ret []*spec3.Parameter, err error) {
+	ret = make([]*spec3.Parameter, len(restParam))
+	for i, v := range restParam {
+		ret[i], err = o.buildParameter(v)
+		if err != nil {
+			return ret, err
+		}
+	}
+	return ret, nil
+}
+
+func (o *openAPI) buildParameter(restParam common.Parameter) (ret *spec3.Parameter, err error) {
+	ret = &spec3.Parameter{
+		ParameterProps: spec3.ParameterProps{
+			Name:        restParam.Name(),
+			Description: restParam.Description(),
+			Required:    restParam.Required(),
+		},
+	}
+	switch restParam.Kind() {
+	case common.BodyParameterKind:
+		return nil, nil
+	case common.PathParameterKind:
+		ret.In = "path"
+		if !restParam.Required() {
+			return ret, fmt.Errorf("path parameters should be marked as required for parameter %v", restParam)
+		}
+	case common.QueryParameterKind:
+		ret.In = "query"
+	case common.HeaderParameterKind:
+		ret.In = "header"
+	/* TODO: add support for the cookie param */
+	default:
+		return ret, fmt.Errorf("unsupported restful parameter kind : %v", restParam.Kind())
+	}
+	openAPIType, openAPIFormat := common.OpenAPITypeFormat(restParam.DataType())
+	if openAPIType == "" {
+		return ret, fmt.Errorf("non-body Restful parameter type should be a simple type, but got : %v", restParam.DataType())
+	}
+
+	ret.Schema = &spec.Schema{
+		SchemaProps: spec.SchemaProps{
+			Type:        []string{openAPIType},
+			Format:      openAPIFormat,
+			UniqueItems: !restParam.AllowMultiple(),
+		},
+	}
+	return ret, nil
+}
+
+func (o *openAPI) buildDefinitionRecursively(name string) error {
+	uniqueName, extensions := o.config.GetDefinitionName(name)
+	if _, ok := o.spec.Components.Schemas[uniqueName]; ok {
+		return nil
+	}
+	if item, ok := o.definitions[name]; ok {
+		schema := &spec.Schema{
+			VendorExtensible:   item.Schema.VendorExtensible,
+			SchemaProps:        item.Schema.SchemaProps,
+			SwaggerSchemaProps: item.Schema.SwaggerSchemaProps,
+		}
+		if extensions != nil {
+			if schema.Extensions == nil {
+				schema.Extensions = spec.Extensions{}
+			}
+			for k, v := range extensions {
+				schema.Extensions[k] = v
+			}
+		}
+		// delete the embedded v2 schema if exists, otherwise no-op
+		delete(schema.VendorExtensible.Extensions, common.ExtensionV2Schema)
+		schema = builderutil.WrapRefs(schema)
+		o.spec.Components.Schemas[uniqueName] = schema
+		for _, v := range item.Dependencies {
+			if err := o.buildDefinitionRecursively(v); err != nil {
+				return err
+			}
+		}
+	} else {
+		return fmt.Errorf("cannot find model definition for %v. If you added a new type, you may need to add +k8s:openapi-gen=true to the package or type and run code-gen again", name)
+	}
+	return nil
+}
+
+func (o *openAPI) buildDefinitionForType(name string) (string, error) {
+	if err := o.buildDefinitionRecursively(name); err != nil {
+		return "", err
+	}
+	defName, _ := o.config.GetDefinitionName(name)
+	return "#/components/schemas/" + common.EscapeJsonPointer(defName), nil
+}
+
+func (o *openAPI) toSchema(name string) (_ *spec.Schema, err error) {
+	if openAPIType, openAPIFormat := common.OpenAPITypeFormat(name); openAPIType != "" {
+		return &spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Type:   []string{openAPIType},
+				Format: openAPIFormat,
+			},
+		}, nil
+	} else {
+		ref, err := o.buildDefinitionForType(name)
+		if err != nil {
+			return nil, err
+		}
+		return &spec.Schema{
+			SchemaProps: spec.SchemaProps{
+				Ref: spec.MustCreateRef(ref),
+			},
+		}, nil
+	}
+}

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

@@ -0,0 +1,52 @@
+/*
+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 builder3
+
+import (
+	"sort"
+
+	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/spec3"
+)
+
+func mapKeyFromParam(param common.Parameter) interface{} {
+	return struct {
+		Name string
+		Kind common.ParameterKind
+	}{
+		Name: param.Name(),
+		Kind: param.Kind(),
+	}
+}
+
+func (s parameters) Len() int      { return len(s) }
+func (s parameters) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+type parameters []*spec3.Parameter
+
+type byNameIn struct {
+	parameters
+}
+
+func (s byNameIn) Less(i, j int) bool {
+	return s.parameters[i].Name < s.parameters[j].Name || (s.parameters[i].Name == s.parameters[j].Name && s.parameters[i].In < s.parameters[j].In)
+}
+
+// SortParameters sorts parameters by Name and In fields.
+func sortParameters(p []*spec3.Parameter) {
+	sort.Sort(byNameIn{p})
+}

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

@@ -20,8 +20,11 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/emicklei/go-restful"
-	"github.com/go-openapi/spec"
+	"github.com/emicklei/go-restful/v3"
+
+	"k8s.io/kube-openapi/pkg/openapiconv"
+	"k8s.io/kube-openapi/pkg/spec3"
+	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
 const (
@@ -57,6 +60,11 @@ 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.
@@ -86,9 +94,19 @@ type Config struct {
 	// 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)
@@ -105,6 +123,92 @@ type Config struct {
 	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
@@ -206,3 +310,11 @@ func EmbedOpenAPIDefinitionIntoV2Extension(main OpenAPIDefinition, embedded Open
 	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/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/common/restfuladapter/adapter.go

@@ -0,0 +1,16 @@
+package restfuladapter
+
+import (
+	"github.com/emicklei/go-restful/v3"
+	"k8s.io/kube-openapi/pkg/common"
+)
+
+// AdaptWebServices adapts a slice of restful.WebService into the common interfaces.
+func AdaptWebServices(webServices []*restful.WebService) []common.RouteContainer {
+	var containers []common.RouteContainer
+	for _, ws := range webServices {
+		containers = append(containers, &WebServiceAdapter{ws})
+	}
+	return containers
+}
+

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

@@ -0,0 +1,54 @@
+package restfuladapter
+
+import (
+	"encoding/json"
+	"github.com/emicklei/go-restful/v3"
+	"k8s.io/kube-openapi/pkg/common"
+)
+
+var _ common.Parameter = &ParamAdapter{}
+
+type ParamAdapter struct {
+	Param *restful.Parameter
+}
+
+func (r *ParamAdapter) MarshalJSON() ([]byte, error) {
+	return json.Marshal(r.Param)
+}
+
+func (r *ParamAdapter) Name() string {
+	return r.Param.Data().Name
+}
+
+func (r *ParamAdapter) Description() string {
+	return r.Param.Data().Description
+}
+
+func (r *ParamAdapter) Required() bool {
+	return r.Param.Data().Required
+}
+
+func (r *ParamAdapter) Kind() common.ParameterKind {
+	switch r.Param.Kind() {
+	case restful.PathParameterKind:
+		return common.PathParameterKind
+	case restful.QueryParameterKind:
+		return common.QueryParameterKind
+	case restful.BodyParameterKind:
+		return common.BodyParameterKind
+	case restful.HeaderParameterKind:
+		return common.HeaderParameterKind
+	case restful.FormParameterKind:
+		return common.FormParameterKind
+	default:
+		return common.UnknownParameterKind
+	}
+}
+
+func (r *ParamAdapter) DataType() string {
+	return r.Param.Data().DataType
+}
+
+func (r *ParamAdapter) AllowMultiple() bool {
+	return r.Param.Data().AllowMultiple
+}

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

@@ -0,0 +1,25 @@
+package restfuladapter
+
+import (
+	"github.com/emicklei/go-restful/v3"
+	"k8s.io/kube-openapi/pkg/common"
+)
+
+var _ common.StatusCodeResponse = &ResponseErrorAdapter{}
+
+// ResponseErrorAdapter adapts a restful.ResponseError to common.StatusCodeResponse.
+type ResponseErrorAdapter struct {
+	Err *restful.ResponseError
+}
+
+func (r *ResponseErrorAdapter) Message() string {
+	return r.Err.Message
+}
+
+func (r *ResponseErrorAdapter) Model() interface{} {
+	return r.Err.Model
+}
+
+func (r *ResponseErrorAdapter) Code() int {
+	return r.Err.Code
+}

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

@@ -0,0 +1,68 @@
+package restfuladapter
+
+import (
+	"github.com/emicklei/go-restful/v3"
+	"k8s.io/kube-openapi/pkg/common"
+)
+
+var _ common.Route = &RouteAdapter{}
+
+// RouteAdapter adapts a restful.Route to common.Route.
+type RouteAdapter struct {
+	Route *restful.Route
+}
+
+func (r *RouteAdapter) StatusCodeResponses() []common.StatusCodeResponse {
+	// go-restful uses the ResponseErrors field to contain both error and regular responses.
+	var responses []common.StatusCodeResponse
+	for _, res := range r.Route.ResponseErrors {
+		localRes := res
+		responses = append(responses, &ResponseErrorAdapter{&localRes})
+	}
+
+	return responses
+}
+
+func (r *RouteAdapter) OperationName() string {
+	return r.Route.Operation
+}
+
+func (r *RouteAdapter) Method() string {
+	return r.Route.Method
+}
+
+func (r *RouteAdapter) Path() string {
+	return r.Route.Path
+}
+
+func (r *RouteAdapter) Parameters() []common.Parameter {
+	var params []common.Parameter
+	for _, rParam := range r.Route.ParameterDocs {
+		params = append(params, &ParamAdapter{rParam})
+	}
+	return params
+}
+
+func (r *RouteAdapter) Description() string {
+	return r.Route.Doc
+}
+
+func (r *RouteAdapter) Consumes() []string {
+	return r.Route.Consumes
+}
+
+func (r *RouteAdapter) Produces() []string {
+	return r.Route.Produces
+}
+
+func (r *RouteAdapter) Metadata() map[string]interface{} {
+	return r.Route.Metadata
+}
+
+func (r *RouteAdapter) RequestPayloadSample() interface{} {
+	return r.Route.ReadSample
+}
+
+func (r *RouteAdapter) ResponsePayloadSample() interface{} {
+	return r.Route.WriteSample
+}

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

@@ -0,0 +1,34 @@
+package restfuladapter
+
+import (
+	"github.com/emicklei/go-restful/v3"
+	"k8s.io/kube-openapi/pkg/common"
+)
+
+var _ common.RouteContainer = &WebServiceAdapter{}
+
+// WebServiceAdapter adapts a restful.WebService to common.RouteContainer.
+type WebServiceAdapter struct {
+	WebService *restful.WebService
+}
+
+func (r *WebServiceAdapter) RootPath() string {
+	return r.WebService.RootPath()
+}
+
+func (r *WebServiceAdapter) PathParameters() []common.Parameter {
+	var params []common.Parameter
+	for _, rParam := range r.WebService.PathParameters() {
+		params = append(params, &ParamAdapter{rParam})
+	}
+	return params
+}
+
+func (r *WebServiceAdapter) Routes() []common.Route {
+	var routes []common.Route
+	for _, rRoute := range r.WebService.Routes() {
+		localRoute := rRoute
+		routes = append(routes, &RouteAdapter{&localRoute})
+	}
+	return routes
+}

vendor/k8s.io/kube-openapi/pkg/generators/enum.go

@@ -0,0 +1,152 @@
+/*
+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 generators
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+
+	"k8s.io/gengo/generator"
+	"k8s.io/gengo/types"
+)
+
+const tagEnumType = "enum"
+const enumTypeDescriptionHeader = "Possible enum values:"
+
+type enumValue struct {
+	Name    string
+	Value   string
+	Comment string
+}
+
+type enumType struct {
+	Name   types.Name
+	Values []*enumValue
+}
+
+// enumMap is a map from the name to the matching enum type.
+type enumMap map[types.Name]*enumType
+
+type enumContext struct {
+	enumTypes enumMap
+}
+
+func newEnumContext(c *generator.Context) *enumContext {
+	return &enumContext{enumTypes: parseEnums(c)}
+}
+
+// EnumType checks and finds the enumType for a given type.
+// If the given type is a known enum type, returns the enumType, true
+// Otherwise, returns nil, false
+func (ec *enumContext) EnumType(t *types.Type) (enum *enumType, isEnum bool) {
+	enum, ok := ec.enumTypes[t.Name]
+	return enum, ok
+}
+
+// ValueStrings returns all possible values of the enum type as strings
+// the results are sorted and quoted as Go literals.
+func (et *enumType) ValueStrings() []string {
+	var values []string
+	for _, value := range et.Values {
+		// use "%q" format to generate a Go literal of the string const value
+		values = append(values, fmt.Sprintf("%q", value.Value))
+	}
+	sort.Strings(values)
+	return values
+}
+
+// DescriptionLines returns a description of the enum in this format:
+//
+// Possible enum values:
+//  - `"value1"` description 1
+//  - `"value2"` description 2
+func (et *enumType) DescriptionLines() []string {
+	var lines []string
+	for _, value := range et.Values {
+		lines = append(lines, value.Description())
+	}
+	sort.Strings(lines)
+	// Prepend an empty string to initiate a new paragraph.
+	return append([]string{"", enumTypeDescriptionHeader}, lines...)
+}
+
+func parseEnums(c *generator.Context) enumMap {
+	// First, find the builtin "string" type
+	stringType := c.Universe.Type(types.Name{Name: "string"})
+
+	enumTypes := make(enumMap)
+	for _, p := range c.Universe {
+		// find all enum types.
+		for _, t := range p.Types {
+			if isEnumType(stringType, t) {
+				if _, ok := enumTypes[t.Name]; !ok {
+					enumTypes[t.Name] = &enumType{
+						Name: t.Name,
+					}
+				}
+			}
+		}
+		// find all enum values from constants, and try to match each with its type.
+		for _, c := range p.Constants {
+			enumType := c.Underlying
+			if _, ok := enumTypes[enumType.Name]; ok {
+				value := &enumValue{
+					Name:    c.Name.Name,
+					Value:   *c.ConstValue,
+					Comment: strings.Join(c.CommentLines, " "),
+				}
+				enumTypes[enumType.Name].appendValue(value)
+			}
+		}
+	}
+
+	return enumTypes
+}
+
+func (et *enumType) appendValue(value *enumValue) {
+	et.Values = append(et.Values, value)
+}
+
+// Description returns the description line for the enumValue
+// with the format:
+//  - `"FooValue"` is the Foo value
+func (ev *enumValue) Description() string {
+	comment := strings.TrimSpace(ev.Comment)
+	// The comment should starts with the type name, trim it first.
+	comment = strings.TrimPrefix(comment, ev.Name)
+	// Trim the possible space after previous step.
+	comment = strings.TrimSpace(comment)
+	// The comment may be multiline, cascade all consecutive whitespaces.
+	comment = whitespaceRegex.ReplaceAllString(comment, " ")
+	return fmt.Sprintf(" - `%q` %s", ev.Value, comment)
+}
+
+// isEnumType checks if a given type is an enum by the definition
+// An enum type should be an alias of string and has tag '+enum' in its comment.
+// Additionally, pass the type of builtin 'string' to check against.
+func isEnumType(stringType *types.Type, t *types.Type) bool {
+	return t.Kind == types.Alias && t.Underlying == stringType && hasEnumTag(t)
+}
+
+func hasEnumTag(t *types.Type) bool {
+	return types.ExtractCommentTags("+", t.CommentLines)[tagEnumType] != nil
+}
+
+// whitespaceRegex is the regex for consecutive whitespaces.
+var whitespaceRegex = regexp.MustCompile(`\s+`)

vendor/k8s.io/kube-openapi/pkg/generators/extension.go

@@ -66,6 +66,10 @@ var tagToExtension = map[string]extensionAttributes{
 		kind:          types.Struct,
 		allowedValues: sets.NewString("atomic", "granular"),
 	},
+	"validations": {
+		xName: "x-kubernetes-validations",
+		kind:  types.Slice,
+	},
 }
 
 // Extension encapsulates information necessary to generate an OpenAPI extension.

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

@@ -103,7 +103,7 @@ func apiTypeFilterFunc(c *generator.Context, t *types.Type) bool {
 }
 
 const (
-	specPackagePath          = "github.com/go-openapi/spec"
+	specPackagePath          = "k8s.io/kube-openapi/pkg/validation/spec"
 	openAPICommonPackagePath = "k8s.io/kube-openapi/pkg/common"
 )
 
@@ -225,6 +225,7 @@ type openAPITypeWriter struct {
 	*generator.SnippetWriter
 	context                *generator.Context
 	refTypes               map[string]*types.Type
+	enumContext            *enumContext
 	GetDefinitionInterface *types.Type
 }
 
@@ -233,6 +234,7 @@ func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context) ope
 		SnippetWriter: sw,
 		context:       c,
 		refTypes:      map[string]*types.Type{},
+		enumContext:   newEnumContext(c),
 	}
 }
 
@@ -277,6 +279,16 @@ func hasOpenAPIDefinitionMethods(t *types.Type) bool {
 	return hasSchemaTypeMethod && hasOpenAPISchemaFormat
 }
 
+func hasOpenAPIV3OneOfMethod(t *types.Type) bool {
+	for mn, mt := range t.Methods {
+		if mn != "OpenAPIV3OneOfTypes" {
+			continue
+		}
+		return methodReturnsValue(mt, "", "[]string")
+	}
+	return false
+}
+
 // typeShortName returns short package name (e.g. the name x appears in package x definition) dot type name.
 func typeShortName(t *types.Type) string {
 	return filepath.Base(t.Name.Package) + "." + t.Name.Name
@@ -346,6 +358,7 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 	case types.Struct:
 		hasV2Definition := hasOpenAPIDefinitionMethod(t)
 		hasV2DefinitionTypeAndFormat := hasOpenAPIDefinitionMethods(t)
+		hasV3OneOfTypes := hasOpenAPIV3OneOfMethod(t)
 		hasV3Definition := hasOpenAPIV3DefinitionMethod(t)
 
 		if hasV2Definition || (hasV3Definition && !hasV2DefinitionTypeAndFormat) {
@@ -367,6 +380,28 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 				"},\n"+
 				"})\n}\n\n", args)
 			return nil
+		case hasV2DefinitionTypeAndFormat && hasV3OneOfTypes:
+			// generate v3 def.
+			g.Do("return common.EmbedOpenAPIDefinitionIntoV2Extension($.OpenAPIDefinition|raw${\n"+
+				"Schema: spec.Schema{\n"+
+				"SchemaProps: spec.SchemaProps{\n", args)
+			g.generateDescription(t.CommentLines)
+			g.Do("OneOf:common.GenerateOpenAPIV3OneOfSchema($.type|raw${}.OpenAPIV3OneOfTypes()),\n"+
+				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n"+
+				"},\n"+
+				"},\n"+
+				"},", args)
+			// generate v2 def.
+			g.Do("$.OpenAPIDefinition|raw${\n"+
+				"Schema: spec.Schema{\n"+
+				"SchemaProps: spec.SchemaProps{\n", args)
+			g.generateDescription(t.CommentLines)
+			g.Do("Type:$.type|raw${}.OpenAPISchemaType(),\n"+
+				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n"+
+				"},\n"+
+				"},\n"+
+				"})\n}\n\n", args)
+			return nil
 		case hasV2DefinitionTypeAndFormat:
 			g.Do("return $.OpenAPIDefinition|raw${\n"+
 				"Schema: spec.Schema{\n"+
@@ -378,6 +413,9 @@ func (g openAPITypeWriter) generate(t *types.Type) error {
 				"},\n"+
 				"}\n}\n\n", args)
 			return nil
+		case hasV3OneOfTypes:
+			// having v3 oneOf types without custom v2 type or format does not make sense.
+			return fmt.Errorf("type %q has v3 one of types but not v2 type or format", t.Name)
 		}
 		g.Do("return $.OpenAPIDefinition|raw${\nSchema: spec.Schema{\nSchemaProps: spec.SchemaProps{\n", args)
 		g.generateDescription(t.CommentLines)
@@ -548,7 +586,7 @@ func mustEnforceDefault(t *types.Type, omitEmpty bool) (interface{}, error) {
 }
 
 func (g openAPITypeWriter) generateDefault(comments []string, t *types.Type, omitEmpty bool) error {
-	t = resolveAliasType(t)
+	t = resolveAliasAndEmbeddedType(t)
 	def, err := defaultFromComments(comments)
 	if err != nil {
 		return err
@@ -601,7 +639,8 @@ func (g openAPITypeWriter) generateDescription(CommentLines []string) {
 		}
 	}
 
-	postDoc := strings.TrimRight(buffer.String(), "\n")
+	postDoc := strings.TrimLeft(buffer.String(), "\n")
+	postDoc = strings.TrimRight(postDoc, "\n")
 	postDoc = strings.Replace(postDoc, "\\\"", "\"", -1) // replace user's \" to "
 	postDoc = strings.Replace(postDoc, "\"", "\\\"", -1) // Escape "
 	postDoc = strings.Replace(postDoc, "\n", "\\n", -1)
@@ -625,7 +664,11 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type)
 		return err
 	}
 	g.Do("SchemaProps: spec.SchemaProps{\n", nil)
-	g.generateDescription(m.CommentLines)
+	var extraComments []string
+	if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum {
+		extraComments = enumType.DescriptionLines()
+	}
+	g.generateDescription(append(m.CommentLines, extraComments...))
 	jsonTags := getJsonTags(m)
 	if len(jsonTags) > 1 && jsonTags[1] == "string" {
 		g.generateSimpleProperty("string", "")
@@ -641,6 +684,10 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type)
 	typeString, format := openapi.OpenAPITypeFormat(t.String())
 	if typeString != "" {
 		g.generateSimpleProperty(typeString, format)
+		if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum {
+			// original type is an enum, add "Enum: " and the values
+			g.Do("Enum: []interface{}{$.$}", strings.Join(enumType.ValueStrings(), ", "))
+		}
 		g.Do("},\n},\n", nil)
 		return nil
 	}
@@ -674,13 +721,18 @@ func (g openAPITypeWriter) generateReferenceProperty(t *types.Type) {
 	g.Do("Ref: ref(\"$.$\"),\n", t.Name.String())
 }
 
-func resolveAliasType(t *types.Type) *types.Type {
+func resolveAliasAndEmbeddedType(t *types.Type) *types.Type {
 	var prev *types.Type
 	for prev != t {
 		prev = t
 		if t.Kind == types.Alias {
 			t = t.Underlying
 		}
+		if t.Kind == types.Struct {
+			if len(t.Members) == 1 && t.Members[0].Embedded {
+				t = t.Members[0].Type
+			}
+		}
 	}
 	return t
 }

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

@@ -16,7 +16,7 @@ limitations under the License.
 
 package handler
 
-import "github.com/go-openapi/spec"
+import "k8s.io/kube-openapi/pkg/validation/spec"
 
 // PruneDefaults remove all the defaults recursively from all the
 // schemas in the definitions, and does not modify the definitions in

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

@@ -20,24 +20,25 @@ import (
 	"bytes"
 	"compress/gzip"
 	"crypto/sha512"
+	"encoding/json"
 	"fmt"
 	"mime"
 	"net/http"
+	"strconv"
 	"sync"
 	"time"
 
 	"github.com/NYTimes/gziphandler"
-	"github.com/emicklei/go-restful"
-	"github.com/go-openapi/spec"
+	"github.com/emicklei/go-restful/v3"
 	"github.com/golang/protobuf/proto"
-	"github.com/googleapis/gnostic/compiler"
-	openapi_v2 "github.com/googleapis/gnostic/openapiv2"
-	jsoniter "github.com/json-iterator/go"
+	openapi_v2 "github.com/google/gnostic/openapiv2"
 	"github.com/munnerz/goautoneg"
-	"gopkg.in/yaml.v2"
-
+	klog "k8s.io/klog/v2"
 	"k8s.io/kube-openapi/pkg/builder"
 	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/common/restfuladapter"
+	"k8s.io/kube-openapi/pkg/internal/handler"
+	"k8s.io/kube-openapi/pkg/validation/spec"
 )
 
 const (
@@ -49,6 +50,13 @@ const (
 	mimePbGz = "application/x-gzip"
 )
 
+func computeETag(data []byte) string {
+	if data == nil {
+		return ""
+	}
+	return fmt.Sprintf("%X", sha512.Sum512(data))
+}
+
 // OpenAPIService is the service responsible for serving OpenAPI spec. It has
 // the ability to safely change the spec while serving it.
 type OpenAPIService struct {
@@ -57,13 +65,9 @@ type OpenAPIService struct {
 
 	lastModified time.Time
 
-	specBytes []byte
-	specPb    []byte
-	specPbGz  []byte
-
-	specBytesETag string
-	specPbETag    string
-	specPbGzETag  string
+	jsonCache  handler.HandlerCache
+	protoCache handler.HandlerCache
+	etagCache  handler.HandlerCache
 }
 
 func init() {
@@ -72,10 +76,6 @@ func init() {
 	mime.AddExtensionType(".gz", mimePbGz)
 }
 
-func computeETag(data []byte) string {
-	return fmt.Sprintf("\"%X\"", sha512.Sum512(data))
-}
-
 // NewOpenAPIService builds an OpenAPIService starting with the given spec.
 func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) {
 	o := &OpenAPIService{}
@@ -85,103 +85,61 @@ func NewOpenAPIService(spec *spec.Swagger) (*OpenAPIService, error) {
 	return o, nil
 }
 
-func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time) {
+func (o *OpenAPIService) getSwaggerBytes() ([]byte, string, time.Time, error) {
 	o.rwMutex.RLock()
 	defer o.rwMutex.RUnlock()
-	return o.specBytes, o.specBytesETag, o.lastModified
+	specBytes, err := o.jsonCache.Get()
+	if err != nil {
+		return nil, "", time.Time{}, err
+	}
+	etagBytes, err := o.etagCache.Get()
+	if err != nil {
+		return nil, "", time.Time{}, err
+	}
+	return specBytes, string(etagBytes), o.lastModified, nil
 }
 
-func (o *OpenAPIService) getSwaggerPbBytes() ([]byte, string, time.Time) {
+func (o *OpenAPIService) getSwaggerPbBytes() ([]byte, string, time.Time, error) {
 	o.rwMutex.RLock()
 	defer o.rwMutex.RUnlock()
-	return o.specPb, o.specPbETag, o.lastModified
-}
-
-func (o *OpenAPIService) getSwaggerPbGzBytes() ([]byte, string, time.Time) {
-	o.rwMutex.RLock()
-	defer o.rwMutex.RUnlock()
-	return o.specPbGz, o.specPbGzETag, o.lastModified
+	specPb, err := o.protoCache.Get()
+	if err != nil {
+		return nil, "", time.Time{}, err
+	}
+	etagBytes, err := o.etagCache.Get()
+	if err != nil {
+		return nil, "", time.Time{}, err
+	}
+	return specPb, string(etagBytes), o.lastModified, nil
 }
 
 func (o *OpenAPIService) UpdateSpec(openapiSpec *spec.Swagger) (err error) {
-	specBytes, err := jsoniter.ConfigCompatibleWithStandardLibrary.Marshal(openapiSpec)
-	if err != nil {
-		return err
-	}
-	var json map[string]interface{}
-	if err := jsoniter.ConfigCompatibleWithStandardLibrary.Unmarshal(specBytes, &json); err != nil {
-		return err
-	}
-	specPb, err := ToProtoBinary(json)
-	if err != nil {
-		return err
-	}
-	specPbGz := toGzip(specPb)
-
-	specBytesETag := computeETag(specBytes)
-	specPbETag := computeETag(specPb)
-	specPbGzETag := computeETag(specPbGz)
-
-	lastModified := time.Now()
-
 	o.rwMutex.Lock()
 	defer o.rwMutex.Unlock()
-
-	o.specBytes = specBytes
-	o.specPb = specPb
-	o.specPbGz = specPbGz
-	o.specBytesETag = specBytesETag
-	o.specPbETag = specPbETag
-	o.specPbGzETag = specPbGzETag
-	o.lastModified = lastModified
+	o.jsonCache = o.jsonCache.New(func() ([]byte, error) {
+		return json.Marshal(openapiSpec)
+	})
+	o.protoCache = o.protoCache.New(func() ([]byte, error) {
+		json, err := o.jsonCache.Get()
+		if err != nil {
+			return nil, err
+		}
+		return ToProtoBinary(json)
+	})
+	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
 }
 
-func jsonToYAML(j map[string]interface{}) yaml.MapSlice {
-	if j == nil {
-		return nil
-	}
-	ret := make(yaml.MapSlice, 0, len(j))
-	for k, v := range j {
-		ret = append(ret, yaml.MapItem{k, jsonToYAMLValue(v)})
-	}
-	return ret
-}
-
-func jsonToYAMLValue(j interface{}) interface{} {
-	switch j := j.(type) {
-	case map[string]interface{}:
-		return jsonToYAML(j)
-	case []interface{}:
-		ret := make([]interface{}, len(j))
-		for i := range j {
-			ret[i] = jsonToYAMLValue(j[i])
-		}
-		return ret
-	case float64:
-		// replicate the logic in https://github.com/go-yaml/yaml/blob/51d6538a90f86fe93ac480b35f37b2be17fef232/resolve.go#L151
-		if i64 := int64(j); j == float64(i64) {
-			if i := int(i64); i64 == int64(i) {
-				return i
-			}
-			return i64
-		}
-		if ui64 := uint64(j); j == float64(ui64) {
-			return ui64
-		}
-		return j
-	case int64:
-		if i := int(j); j == int64(i) {
-			return i
-		}
-		return j
-	}
-	return j
-}
-
-func ToProtoBinary(json map[string]interface{}) ([]byte, error) {
-	document, err := openapi_v2.NewDocument(jsonToYAML(json), compiler.NewContext("$root", nil))
+func ToProtoBinary(json []byte) ([]byte, error) {
+	document, err := openapi_v2.ParseDocument(json)
 	if err != nil {
 		return nil, err
 	}
@@ -212,7 +170,7 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
 	accepted := []struct {
 		Type           string
 		SubType        string
-		GetDataAndETag func() ([]byte, string, time.Time)
+		GetDataAndETag func() ([]byte, string, time.Time, error)
 	}{
 		{"application", "json", o.getSwaggerBytes},
 		{"application", "com.github.proto-openapi.spec.v2@v1.0+protobuf", o.getSwaggerPbBytes},
@@ -236,8 +194,17 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
 					}
 
 					// serve the first matching media type in the sorted clause list
-					data, etag, lastModified := accepts.GetDataAndETag()
-					w.Header().Set("Etag", etag)
+					data, etag, lastModified, err := accepts.GetDataAndETag()
+					if err != nil {
+						klog.Errorf("Error in OpenAPI handler: %s", err)
+						// only return a 503 if we have no older cache data to serve
+						if data == nil {
+							w.WriteHeader(http.StatusServiceUnavailable)
+							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))
 					// ServeContent will take care of caching using eTag.
 					http.ServeContent(w, r, servePath, lastModified, bytes.NewReader(data))
 					return
@@ -254,8 +221,16 @@ func (o *OpenAPIService) RegisterOpenAPIVersionedService(servePath string, handl
 
 // BuildAndRegisterOpenAPIVersionedService builds the spec and registers a handler to provide access to it.
 // Use this method if your OpenAPI spec is static. If you want to update the spec, use BuildOpenAPISpec then RegisterOpenAPIVersionedService.
+//
+// Deprecated: BuildAndRegisterOpenAPIVersionedServiceFromRoutes should be used instead.
 func BuildAndRegisterOpenAPIVersionedService(servePath string, webServices []*restful.WebService, config *common.Config, handler common.PathHandler) (*OpenAPIService, error) {
-	spec, err := builder.BuildOpenAPISpec(webServices, config)
+	return BuildAndRegisterOpenAPIVersionedServiceFromRoutes(servePath, restfuladapter.AdaptWebServices(webServices), config, handler)
+}
+
+// BuildAndRegisterOpenAPIVersionedServiceFromRoutes builds the spec and registers a handler to provide access to it.
+// Use this method if your OpenAPI spec is static. If you want to update the spec, use BuildOpenAPISpec then RegisterOpenAPIVersionedService.
+func BuildAndRegisterOpenAPIVersionedServiceFromRoutes(servePath string, routeContainers []common.RouteContainer, config *common.Config, handler common.PathHandler) (*OpenAPIService, error) {
+	spec, err := builder.BuildOpenAPISpecFromRoutes(routeContainers, config)
 	if err != nil {
 		return nil, err
 	}

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/schemaconv/smd.go

@@ -167,6 +167,20 @@ func (c *convert) makeRef(model proto.Schema, preserveUnknownFields bool) schema
 		// reference a named type
 		_, n := path.Split(r.Reference())
 		tr.NamedType = &n
+
+		ext := model.GetExtensions()
+		if val, ok := ext["x-kubernetes-map-type"]; ok {
+			switch val {
+			case "atomic":
+				relationship := schema.Atomic
+				tr.ElementRelationship = &relationship
+			case "granular":
+				relationship := schema.Separable
+				tr.ElementRelationship = &relationship
+			default:
+				c.reportError("unknown map type %v", val)
+			}
+		}
 	} else {
 		// compute the type inline
 		c2 := c.push("inlined in "+c.currentName, &tr.Inlined)
@@ -449,10 +463,7 @@ func (c *convert) VisitPrimitive(p *proto.Primitive) {
 }
 
 func (c *convert) VisitArbitrary(a *proto.Arbitrary) {
-	*c.top() = untypedDef.Atom
-	if c.preserveUnknownFields {
-		*c.top() = deducedDef.Atom
-	}
+	*c.top() = deducedDef.Atom
 }
 
 func (c *convert) VisitReference(proto.Reference) {

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)
+}