rebase: update kubernetes dep to 1.24.0

As kubernetes 1.24.0 is released, updating
kubernetes dependencies to 1.24.0

updates: #3086

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

vendor/k8s.io/kube-openapi/pkg/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"`
+}