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/github.com/google/gnostic/jsonschema/README.md

@@ -0,0 +1,4 @@
+# jsonschema
+
+This directory contains code for reading, writing, and manipulating JSON
+schemas.

vendor/github.com/google/gnostic/jsonschema/base.go

@@ -0,0 +1,84 @@
+
+// THIS FILE IS AUTOMATICALLY GENERATED.
+
+package jsonschema
+
+import (
+	"encoding/base64"
+)
+
+func baseSchemaBytes() ([]byte, error){
+	return base64.StdEncoding.DecodeString(
+`ewogICAgImlkIjogImh0dHA6Ly9qc29uLXNjaGVtYS5vcmcvZHJhZnQtMDQvc2NoZW1hIyIsCiAgICAi
+JHNjaGVtYSI6ICJodHRwOi8vanNvbi1zY2hlbWEub3JnL2RyYWZ0LTA0L3NjaGVtYSMiLAogICAgImRl
+c2NyaXB0aW9uIjogIkNvcmUgc2NoZW1hIG1ldGEtc2NoZW1hIiwKICAgICJkZWZpbml0aW9ucyI6IHsK
+ICAgICAgICAic2NoZW1hQXJyYXkiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImFycmF5IiwKICAgICAg
+ICAgICAgIm1pbkl0ZW1zIjogMSwKICAgICAgICAgICAgIml0ZW1zIjogeyAiJHJlZiI6ICIjIiB9CiAg
+ICAgICAgfSwKICAgICAgICAicG9zaXRpdmVJbnRlZ2VyIjogewogICAgICAgICAgICAidHlwZSI6ICJp
+bnRlZ2VyIiwKICAgICAgICAgICAgIm1pbmltdW0iOiAwCiAgICAgICAgfSwKICAgICAgICAicG9zaXRp
+dmVJbnRlZ2VyRGVmYXVsdDAiOiB7CiAgICAgICAgICAgICJhbGxPZiI6IFsgeyAiJHJlZiI6ICIjL2Rl
+ZmluaXRpb25zL3Bvc2l0aXZlSW50ZWdlciIgfSwgeyAiZGVmYXVsdCI6IDAgfSBdCiAgICAgICAgfSwK
+ICAgICAgICAic2ltcGxlVHlwZXMiOiB7CiAgICAgICAgICAgICJlbnVtIjogWyAiYXJyYXkiLCAiYm9v
+bGVhbiIsICJpbnRlZ2VyIiwgIm51bGwiLCAibnVtYmVyIiwgIm9iamVjdCIsICJzdHJpbmciIF0KICAg
+ICAgICB9LAogICAgICAgICJzdHJpbmdBcnJheSI6IHsKICAgICAgICAgICAgInR5cGUiOiAiYXJyYXki
+LAogICAgICAgICAgICAiaXRlbXMiOiB7ICJ0eXBlIjogInN0cmluZyIgfSwKICAgICAgICAgICAgIm1p
+bkl0ZW1zIjogMSwKICAgICAgICAgICAgInVuaXF1ZUl0ZW1zIjogdHJ1ZQogICAgICAgIH0KICAgIH0s
+CiAgICAidHlwZSI6ICJvYmplY3QiLAogICAgInByb3BlcnRpZXMiOiB7CiAgICAgICAgImlkIjogewog
+ICAgICAgICAgICAidHlwZSI6ICJzdHJpbmciLAogICAgICAgICAgICAiZm9ybWF0IjogInVyaSIKICAg
+ICAgICB9LAogICAgICAgICIkc2NoZW1hIjogewogICAgICAgICAgICAidHlwZSI6ICJzdHJpbmciLAog
+ICAgICAgICAgICAiZm9ybWF0IjogInVyaSIKICAgICAgICB9LAogICAgICAgICJ0aXRsZSI6IHsKICAg
+ICAgICAgICAgInR5cGUiOiAic3RyaW5nIgogICAgICAgIH0sCiAgICAgICAgImRlc2NyaXB0aW9uIjog
+ewogICAgICAgICAgICAidHlwZSI6ICJzdHJpbmciCiAgICAgICAgfSwKICAgICAgICAiZGVmYXVsdCI6
+IHt9LAogICAgICAgICJtdWx0aXBsZU9mIjogewogICAgICAgICAgICAidHlwZSI6ICJudW1iZXIiLAog
+ICAgICAgICAgICAibWluaW11bSI6IDAsCiAgICAgICAgICAgICJleGNsdXNpdmVNaW5pbXVtIjogdHJ1
+ZQogICAgICAgIH0sCiAgICAgICAgIm1heGltdW0iOiB7CiAgICAgICAgICAgICJ0eXBlIjogIm51bWJl
+ciIKICAgICAgICB9LAogICAgICAgICJleGNsdXNpdmVNYXhpbXVtIjogewogICAgICAgICAgICAidHlw
+ZSI6ICJib29sZWFuIiwKICAgICAgICAgICAgImRlZmF1bHQiOiBmYWxzZQogICAgICAgIH0sCiAgICAg
+ICAgIm1pbmltdW0iOiB7CiAgICAgICAgICAgICJ0eXBlIjogIm51bWJlciIKICAgICAgICB9LAogICAg
+ICAgICJleGNsdXNpdmVNaW5pbXVtIjogewogICAgICAgICAgICAidHlwZSI6ICJib29sZWFuIiwKICAg
+ICAgICAgICAgImRlZmF1bHQiOiBmYWxzZQogICAgICAgIH0sCiAgICAgICAgIm1heExlbmd0aCI6IHsg
+IiRyZWYiOiAiIy9kZWZpbml0aW9ucy9wb3NpdGl2ZUludGVnZXIiIH0sCiAgICAgICAgIm1pbkxlbmd0
+aCI6IHsgIiRyZWYiOiAiIy9kZWZpbml0aW9ucy9wb3NpdGl2ZUludGVnZXJEZWZhdWx0MCIgfSwKICAg
+ICAgICAicGF0dGVybiI6IHsKICAgICAgICAgICAgInR5cGUiOiAic3RyaW5nIiwKICAgICAgICAgICAg
+ImZvcm1hdCI6ICJyZWdleCIKICAgICAgICB9LAogICAgICAgICJhZGRpdGlvbmFsSXRlbXMiOiB7CiAg
+ICAgICAgICAgICJhbnlPZiI6IFsKICAgICAgICAgICAgICAgIHsgInR5cGUiOiAiYm9vbGVhbiIgfSwK
+ICAgICAgICAgICAgICAgIHsgIiRyZWYiOiAiIyIgfQogICAgICAgICAgICBdLAogICAgICAgICAgICAi
+ZGVmYXVsdCI6IHt9CiAgICAgICAgfSwKICAgICAgICAiaXRlbXMiOiB7CiAgICAgICAgICAgICJhbnlP
+ZiI6IFsKICAgICAgICAgICAgICAgIHsgIiRyZWYiOiAiIyIgfSwKICAgICAgICAgICAgICAgIHsgIiRy
+ZWYiOiAiIy9kZWZpbml0aW9ucy9zY2hlbWFBcnJheSIgfQogICAgICAgICAgICBdLAogICAgICAgICAg
+ICAiZGVmYXVsdCI6IHt9CiAgICAgICAgfSwKICAgICAgICAibWF4SXRlbXMiOiB7ICIkcmVmIjogIiMv
+ZGVmaW5pdGlvbnMvcG9zaXRpdmVJbnRlZ2VyIiB9LAogICAgICAgICJtaW5JdGVtcyI6IHsgIiRyZWYi
+OiAiIy9kZWZpbml0aW9ucy9wb3NpdGl2ZUludGVnZXJEZWZhdWx0MCIgfSwKICAgICAgICAidW5pcXVl
+SXRlbXMiOiB7CiAgICAgICAgICAgICJ0eXBlIjogImJvb2xlYW4iLAogICAgICAgICAgICAiZGVmYXVs
+dCI6IGZhbHNlCiAgICAgICAgfSwKICAgICAgICAibWF4UHJvcGVydGllcyI6IHsgIiRyZWYiOiAiIy9k
+ZWZpbml0aW9ucy9wb3NpdGl2ZUludGVnZXIiIH0sCiAgICAgICAgIm1pblByb3BlcnRpZXMiOiB7ICIk
+cmVmIjogIiMvZGVmaW5pdGlvbnMvcG9zaXRpdmVJbnRlZ2VyRGVmYXVsdDAiIH0sCiAgICAgICAgInJl
+cXVpcmVkIjogeyAiJHJlZiI6ICIjL2RlZmluaXRpb25zL3N0cmluZ0FycmF5IiB9LAogICAgICAgICJh
+ZGRpdGlvbmFsUHJvcGVydGllcyI6IHsKICAgICAgICAgICAgImFueU9mIjogWwogICAgICAgICAgICAg
+ICAgeyAidHlwZSI6ICJib29sZWFuIiB9LAogICAgICAgICAgICAgICAgeyAiJHJlZiI6ICIjIiB9CiAg
+ICAgICAgICAgIF0sCiAgICAgICAgICAgICJkZWZhdWx0Ijoge30KICAgICAgICB9LAogICAgICAgICJk
+ZWZpbml0aW9ucyI6IHsKICAgICAgICAgICAgInR5cGUiOiAib2JqZWN0IiwKICAgICAgICAgICAgImFk
+ZGl0aW9uYWxQcm9wZXJ0aWVzIjogeyAiJHJlZiI6ICIjIiB9LAogICAgICAgICAgICAiZGVmYXVsdCI6
+IHt9CiAgICAgICAgfSwKICAgICAgICAicHJvcGVydGllcyI6IHsKICAgICAgICAgICAgInR5cGUiOiAi
+b2JqZWN0IiwKICAgICAgICAgICAgImFkZGl0aW9uYWxQcm9wZXJ0aWVzIjogeyAiJHJlZiI6ICIjIiB9
+LAogICAgICAgICAgICAiZGVmYXVsdCI6IHt9CiAgICAgICAgfSwKICAgICAgICAicGF0dGVyblByb3Bl
+cnRpZXMiOiB7CiAgICAgICAgICAgICJ0eXBlIjogIm9iamVjdCIsCiAgICAgICAgICAgICJhZGRpdGlv
+bmFsUHJvcGVydGllcyI6IHsgIiRyZWYiOiAiIyIgfSwKICAgICAgICAgICAgImRlZmF1bHQiOiB7fQog
+ICAgICAgIH0sCiAgICAgICAgImRlcGVuZGVuY2llcyI6IHsKICAgICAgICAgICAgInR5cGUiOiAib2Jq
+ZWN0IiwKICAgICAgICAgICAgImFkZGl0aW9uYWxQcm9wZXJ0aWVzIjogewogICAgICAgICAgICAgICAg
+ImFueU9mIjogWwogICAgICAgICAgICAgICAgICAgIHsgIiRyZWYiOiAiIyIgfSwKICAgICAgICAgICAg
+ICAgICAgICB7ICIkcmVmIjogIiMvZGVmaW5pdGlvbnMvc3RyaW5nQXJyYXkiIH0KICAgICAgICAgICAg
+ICAgIF0KICAgICAgICAgICAgfQogICAgICAgIH0sCiAgICAgICAgImVudW0iOiB7CiAgICAgICAgICAg
+ICJ0eXBlIjogImFycmF5IiwKICAgICAgICAgICAgIm1pbkl0ZW1zIjogMSwKICAgICAgICAgICAgInVu
+aXF1ZUl0ZW1zIjogdHJ1ZQogICAgICAgIH0sCiAgICAgICAgInR5cGUiOiB7CiAgICAgICAgICAgICJh
+bnlPZiI6IFsKICAgICAgICAgICAgICAgIHsgIiRyZWYiOiAiIy9kZWZpbml0aW9ucy9zaW1wbGVUeXBl
+cyIgfSwKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAidHlwZSI6ICJhcnJheSIs
+CiAgICAgICAgICAgICAgICAgICAgIml0ZW1zIjogeyAiJHJlZiI6ICIjL2RlZmluaXRpb25zL3NpbXBs
+ZVR5cGVzIiB9LAogICAgICAgICAgICAgICAgICAgICJtaW5JdGVtcyI6IDEsCiAgICAgICAgICAgICAg
+ICAgICAgInVuaXF1ZUl0ZW1zIjogdHJ1ZQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICBdCiAg
+ICAgICAgfSwKICAgICAgICAiYWxsT2YiOiB7ICIkcmVmIjogIiMvZGVmaW5pdGlvbnMvc2NoZW1hQXJy
+YXkiIH0sCiAgICAgICAgImFueU9mIjogeyAiJHJlZiI6ICIjL2RlZmluaXRpb25zL3NjaGVtYUFycmF5
+IiB9LAogICAgICAgICJvbmVPZiI6IHsgIiRyZWYiOiAiIy9kZWZpbml0aW9ucy9zY2hlbWFBcnJheSIg
+fSwKICAgICAgICAibm90IjogeyAiJHJlZiI6ICIjIiB9CiAgICB9LAogICAgImRlcGVuZGVuY2llcyI6
+IHsKICAgICAgICAiZXhjbHVzaXZlTWF4aW11bSI6IFsgIm1heGltdW0iIF0sCiAgICAgICAgImV4Y2x1
+c2l2ZU1pbmltdW0iOiBbICJtaW5pbXVtIiBdCiAgICB9LAogICAgImRlZmF1bHQiOiB7fQp9Cg==`)}

vendor/github.com/google/gnostic/jsonschema/display.go

@@ -0,0 +1,229 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// 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 jsonschema
+
+import (
+	"fmt"
+	"strings"
+)
+
+//
+// DISPLAY
+// The following methods display Schemas.
+//
+
+// Description returns a string representation of a string or string array.
+func (s *StringOrStringArray) Description() string {
+	if s.String != nil {
+		return *s.String
+	}
+	if s.StringArray != nil {
+		return strings.Join(*s.StringArray, ", ")
+	}
+	return ""
+}
+
+// Returns a string representation of a Schema.
+func (schema *Schema) String() string {
+	return schema.describeSchema("")
+}
+
+// Helper: Returns a string representation of a Schema indented by a specified string.
+func (schema *Schema) describeSchema(indent string) string {
+	result := ""
+	if schema.Schema != nil {
+		result += indent + "$schema: " + *(schema.Schema) + "\n"
+	}
+	if schema.ID != nil {
+		result += indent + "id: " + *(schema.ID) + "\n"
+	}
+	if schema.MultipleOf != nil {
+		result += indent + fmt.Sprintf("multipleOf: %+v\n", *(schema.MultipleOf))
+	}
+	if schema.Maximum != nil {
+		result += indent + fmt.Sprintf("maximum: %+v\n", *(schema.Maximum))
+	}
+	if schema.ExclusiveMaximum != nil {
+		result += indent + fmt.Sprintf("exclusiveMaximum: %+v\n", *(schema.ExclusiveMaximum))
+	}
+	if schema.Minimum != nil {
+		result += indent + fmt.Sprintf("minimum: %+v\n", *(schema.Minimum))
+	}
+	if schema.ExclusiveMinimum != nil {
+		result += indent + fmt.Sprintf("exclusiveMinimum: %+v\n", *(schema.ExclusiveMinimum))
+	}
+	if schema.MaxLength != nil {
+		result += indent + fmt.Sprintf("maxLength: %+v\n", *(schema.MaxLength))
+	}
+	if schema.MinLength != nil {
+		result += indent + fmt.Sprintf("minLength: %+v\n", *(schema.MinLength))
+	}
+	if schema.Pattern != nil {
+		result += indent + fmt.Sprintf("pattern: %+v\n", *(schema.Pattern))
+	}
+	if schema.AdditionalItems != nil {
+		s := schema.AdditionalItems.Schema
+		if s != nil {
+			result += indent + "additionalItems:\n"
+			result += s.describeSchema(indent + "  ")
+		} else {
+			b := *(schema.AdditionalItems.Boolean)
+			result += indent + fmt.Sprintf("additionalItems: %+v\n", b)
+		}
+	}
+	if schema.Items != nil {
+		result += indent + "items:\n"
+		items := schema.Items
+		if items.SchemaArray != nil {
+			for i, s := range *(items.SchemaArray) {
+				result += indent + "  " + fmt.Sprintf("%d", i) + ":\n"
+				result += s.describeSchema(indent + "  " + "  ")
+			}
+		} else if items.Schema != nil {
+			result += items.Schema.describeSchema(indent + "  " + "  ")
+		}
+	}
+	if schema.MaxItems != nil {
+		result += indent + fmt.Sprintf("maxItems: %+v\n", *(schema.MaxItems))
+	}
+	if schema.MinItems != nil {
+		result += indent + fmt.Sprintf("minItems: %+v\n", *(schema.MinItems))
+	}
+	if schema.UniqueItems != nil {
+		result += indent + fmt.Sprintf("uniqueItems: %+v\n", *(schema.UniqueItems))
+	}
+	if schema.MaxProperties != nil {
+		result += indent + fmt.Sprintf("maxProperties: %+v\n", *(schema.MaxProperties))
+	}
+	if schema.MinProperties != nil {
+		result += indent + fmt.Sprintf("minProperties: %+v\n", *(schema.MinProperties))
+	}
+	if schema.Required != nil {
+		result += indent + fmt.Sprintf("required: %+v\n", *(schema.Required))
+	}
+	if schema.AdditionalProperties != nil {
+		s := schema.AdditionalProperties.Schema
+		if s != nil {
+			result += indent + "additionalProperties:\n"
+			result += s.describeSchema(indent + "  ")
+		} else {
+			b := *(schema.AdditionalProperties.Boolean)
+			result += indent + fmt.Sprintf("additionalProperties: %+v\n", b)
+		}
+	}
+	if schema.Properties != nil {
+		result += indent + "properties:\n"
+		for _, pair := range *(schema.Properties) {
+			name := pair.Name
+			s := pair.Value
+			result += indent + "  " + name + ":\n"
+			result += s.describeSchema(indent + "  " + "  ")
+		}
+	}
+	if schema.PatternProperties != nil {
+		result += indent + "patternProperties:\n"
+		for _, pair := range *(schema.PatternProperties) {
+			name := pair.Name
+			s := pair.Value
+			result += indent + "  " + name + ":\n"
+			result += s.describeSchema(indent + "  " + "  ")
+		}
+	}
+	if schema.Dependencies != nil {
+		result += indent + "dependencies:\n"
+		for _, pair := range *(schema.Dependencies) {
+			name := pair.Name
+			schemaOrStringArray := pair.Value
+			s := schemaOrStringArray.Schema
+			if s != nil {
+				result += indent + "  " + name + ":\n"
+				result += s.describeSchema(indent + "  " + "  ")
+			} else {
+				a := schemaOrStringArray.StringArray
+				if a != nil {
+					result += indent + "  " + name + ":\n"
+					for _, s2 := range *a {
+						result += indent + "  " + "  " + s2 + "\n"
+					}
+				}
+			}
+
+		}
+	}
+	if schema.Enumeration != nil {
+		result += indent + "enumeration:\n"
+		for _, value := range *(schema.Enumeration) {
+			if value.String != nil {
+				result += indent + "  " + fmt.Sprintf("%+v\n", *value.String)
+			} else {
+				result += indent + "  " + fmt.Sprintf("%+v\n", *value.Bool)
+			}
+		}
+	}
+	if schema.Type != nil {
+		result += indent + fmt.Sprintf("type: %+v\n", schema.Type.Description())
+	}
+	if schema.AllOf != nil {
+		result += indent + "allOf:\n"
+		for _, s := range *(schema.AllOf) {
+			result += s.describeSchema(indent + "  ")
+			result += indent + "-\n"
+		}
+	}
+	if schema.AnyOf != nil {
+		result += indent + "anyOf:\n"
+		for _, s := range *(schema.AnyOf) {
+			result += s.describeSchema(indent + "  ")
+			result += indent + "-\n"
+		}
+	}
+	if schema.OneOf != nil {
+		result += indent + "oneOf:\n"
+		for _, s := range *(schema.OneOf) {
+			result += s.describeSchema(indent + "  ")
+			result += indent + "-\n"
+		}
+	}
+	if schema.Not != nil {
+		result += indent + "not:\n"
+		result += schema.Not.describeSchema(indent + "  ")
+	}
+	if schema.Definitions != nil {
+		result += indent + "definitions:\n"
+		for _, pair := range *(schema.Definitions) {
+			name := pair.Name
+			s := pair.Value
+			result += indent + "  " + name + ":\n"
+			result += s.describeSchema(indent + "  " + "  ")
+		}
+	}
+	if schema.Title != nil {
+		result += indent + "title: " + *(schema.Title) + "\n"
+	}
+	if schema.Description != nil {
+		result += indent + "description: " + *(schema.Description) + "\n"
+	}
+	if schema.Default != nil {
+		result += indent + "default:\n"
+		result += indent + fmt.Sprintf("  %+v\n", *(schema.Default))
+	}
+	if schema.Format != nil {
+		result += indent + "format: " + *(schema.Format) + "\n"
+	}
+	if schema.Ref != nil {
+		result += indent + "$ref: " + *(schema.Ref) + "\n"
+	}
+	return result
+}

vendor/github.com/google/gnostic/jsonschema/models.go

@@ -0,0 +1,228 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// 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 jsonschema supports the reading, writing, and manipulation
+// of JSON Schemas.
+package jsonschema
+
+import "gopkg.in/yaml.v3"
+
+// The Schema struct models a JSON Schema and, because schemas are
+// defined hierarchically, contains many references to itself.
+// All fields are pointers and are nil if the associated values
+// are not specified.
+type Schema struct {
+	Schema *string // $schema
+	ID     *string // id keyword used for $ref resolution scope
+	Ref    *string // $ref, i.e. JSON Pointers
+
+	// http://json-schema.org/latest/json-schema-validation.html
+	// 5.1.  Validation keywords for numeric instances (number and integer)
+	MultipleOf       *SchemaNumber
+	Maximum          *SchemaNumber
+	ExclusiveMaximum *bool
+	Minimum          *SchemaNumber
+	ExclusiveMinimum *bool
+
+	// 5.2.  Validation keywords for strings
+	MaxLength *int64
+	MinLength *int64
+	Pattern   *string
+
+	// 5.3.  Validation keywords for arrays
+	AdditionalItems *SchemaOrBoolean
+	Items           *SchemaOrSchemaArray
+	MaxItems        *int64
+	MinItems        *int64
+	UniqueItems     *bool
+
+	// 5.4.  Validation keywords for objects
+	MaxProperties        *int64
+	MinProperties        *int64
+	Required             *[]string
+	AdditionalProperties *SchemaOrBoolean
+	Properties           *[]*NamedSchema
+	PatternProperties    *[]*NamedSchema
+	Dependencies         *[]*NamedSchemaOrStringArray
+
+	// 5.5.  Validation keywords for any instance type
+	Enumeration *[]SchemaEnumValue
+	Type        *StringOrStringArray
+	AllOf       *[]*Schema
+	AnyOf       *[]*Schema
+	OneOf       *[]*Schema
+	Not         *Schema
+	Definitions *[]*NamedSchema
+
+	// 6.  Metadata keywords
+	Title       *string
+	Description *string
+	Default     *yaml.Node
+
+	// 7.  Semantic validation with "format"
+	Format *string
+}
+
+// These helper structs represent "combination" types that generally can
+// have values of one type or another. All are used to represent parts
+// of Schemas.
+
+// SchemaNumber represents a value that can be either an Integer or a Float.
+type SchemaNumber struct {
+	Integer *int64
+	Float   *float64
+}
+
+// NewSchemaNumberWithInteger creates and returns a new object
+func NewSchemaNumberWithInteger(i int64) *SchemaNumber {
+	result := &SchemaNumber{}
+	result.Integer = &i
+	return result
+}
+
+// NewSchemaNumberWithFloat creates and returns a new object
+func NewSchemaNumberWithFloat(f float64) *SchemaNumber {
+	result := &SchemaNumber{}
+	result.Float = &f
+	return result
+}
+
+// SchemaOrBoolean represents a value that can be either a Schema or a Boolean.
+type SchemaOrBoolean struct {
+	Schema  *Schema
+	Boolean *bool
+}
+
+// NewSchemaOrBooleanWithSchema creates and returns a new object
+func NewSchemaOrBooleanWithSchema(s *Schema) *SchemaOrBoolean {
+	result := &SchemaOrBoolean{}
+	result.Schema = s
+	return result
+}
+
+// NewSchemaOrBooleanWithBoolean creates and returns a new object
+func NewSchemaOrBooleanWithBoolean(b bool) *SchemaOrBoolean {
+	result := &SchemaOrBoolean{}
+	result.Boolean = &b
+	return result
+}
+
+// StringOrStringArray represents a value that can be either
+// a String or an Array of Strings.
+type StringOrStringArray struct {
+	String      *string
+	StringArray *[]string
+}
+
+// NewStringOrStringArrayWithString creates and returns a new object
+func NewStringOrStringArrayWithString(s string) *StringOrStringArray {
+	result := &StringOrStringArray{}
+	result.String = &s
+	return result
+}
+
+// NewStringOrStringArrayWithStringArray creates and returns a new object
+func NewStringOrStringArrayWithStringArray(a []string) *StringOrStringArray {
+	result := &StringOrStringArray{}
+	result.StringArray = &a
+	return result
+}
+
+// SchemaOrStringArray represents a value that can be either
+// a Schema or an Array of Strings.
+type SchemaOrStringArray struct {
+	Schema      *Schema
+	StringArray *[]string
+}
+
+// SchemaOrSchemaArray represents a value that can be either
+// a Schema or an Array of Schemas.
+type SchemaOrSchemaArray struct {
+	Schema      *Schema
+	SchemaArray *[]*Schema
+}
+
+// NewSchemaOrSchemaArrayWithSchema creates and returns a new object
+func NewSchemaOrSchemaArrayWithSchema(s *Schema) *SchemaOrSchemaArray {
+	result := &SchemaOrSchemaArray{}
+	result.Schema = s
+	return result
+}
+
+// NewSchemaOrSchemaArrayWithSchemaArray creates and returns a new object
+func NewSchemaOrSchemaArrayWithSchemaArray(a []*Schema) *SchemaOrSchemaArray {
+	result := &SchemaOrSchemaArray{}
+	result.SchemaArray = &a
+	return result
+}
+
+// SchemaEnumValue represents a value that can be part of an
+// enumeration in a Schema.
+type SchemaEnumValue struct {
+	String *string
+	Bool   *bool
+}
+
+// NamedSchema is a name-value pair that is used to emulate maps
+// with ordered keys.
+type NamedSchema struct {
+	Name  string
+	Value *Schema
+}
+
+// NewNamedSchema creates and returns a new object
+func NewNamedSchema(name string, value *Schema) *NamedSchema {
+	return &NamedSchema{Name: name, Value: value}
+}
+
+// NamedSchemaOrStringArray is a name-value pair that is used
+// to emulate maps with ordered keys.
+type NamedSchemaOrStringArray struct {
+	Name  string
+	Value *SchemaOrStringArray
+}
+
+// Access named subschemas by name
+
+func namedSchemaArrayElementWithName(array *[]*NamedSchema, name string) *Schema {
+	if array == nil {
+		return nil
+	}
+	for _, pair := range *array {
+		if pair.Name == name {
+			return pair.Value
+		}
+	}
+	return nil
+}
+
+// PropertyWithName returns the selected element.
+func (s *Schema) PropertyWithName(name string) *Schema {
+	return namedSchemaArrayElementWithName(s.Properties, name)
+}
+
+// PatternPropertyWithName returns the selected element.
+func (s *Schema) PatternPropertyWithName(name string) *Schema {
+	return namedSchemaArrayElementWithName(s.PatternProperties, name)
+}
+
+// DefinitionWithName returns the selected element.
+func (s *Schema) DefinitionWithName(name string) *Schema {
+	return namedSchemaArrayElementWithName(s.Definitions, name)
+}
+
+// AddProperty adds a named property.
+func (s *Schema) AddProperty(name string, property *Schema) {
+	*s.Properties = append(*s.Properties, NewNamedSchema(name, property))
+}

vendor/github.com/google/gnostic/jsonschema/operations.go

@@ -0,0 +1,394 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// 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 jsonschema
+
+import (
+	"fmt"
+	"log"
+	"strings"
+)
+
+//
+// OPERATIONS
+// The following methods perform operations on Schemas.
+//
+
+// IsEmpty returns true if no members of the Schema are specified.
+func (schema *Schema) IsEmpty() bool {
+	return (schema.Schema == nil) &&
+		(schema.ID == nil) &&
+		(schema.MultipleOf == nil) &&
+		(schema.Maximum == nil) &&
+		(schema.ExclusiveMaximum == nil) &&
+		(schema.Minimum == nil) &&
+		(schema.ExclusiveMinimum == nil) &&
+		(schema.MaxLength == nil) &&
+		(schema.MinLength == nil) &&
+		(schema.Pattern == nil) &&
+		(schema.AdditionalItems == nil) &&
+		(schema.Items == nil) &&
+		(schema.MaxItems == nil) &&
+		(schema.MinItems == nil) &&
+		(schema.UniqueItems == nil) &&
+		(schema.MaxProperties == nil) &&
+		(schema.MinProperties == nil) &&
+		(schema.Required == nil) &&
+		(schema.AdditionalProperties == nil) &&
+		(schema.Properties == nil) &&
+		(schema.PatternProperties == nil) &&
+		(schema.Dependencies == nil) &&
+		(schema.Enumeration == nil) &&
+		(schema.Type == nil) &&
+		(schema.AllOf == nil) &&
+		(schema.AnyOf == nil) &&
+		(schema.OneOf == nil) &&
+		(schema.Not == nil) &&
+		(schema.Definitions == nil) &&
+		(schema.Title == nil) &&
+		(schema.Description == nil) &&
+		(schema.Default == nil) &&
+		(schema.Format == nil) &&
+		(schema.Ref == nil)
+}
+
+// IsEqual returns true if two schemas are equal.
+func (schema *Schema) IsEqual(schema2 *Schema) bool {
+	return schema.String() == schema2.String()
+}
+
+// SchemaOperation represents a function that can be applied to a Schema.
+type SchemaOperation func(schema *Schema, context string)
+
+// Applies a specified function to a Schema and all of the Schemas that it contains.
+func (schema *Schema) applyToSchemas(operation SchemaOperation, context string) {
+
+	if schema.AdditionalItems != nil {
+		s := schema.AdditionalItems.Schema
+		if s != nil {
+			s.applyToSchemas(operation, "AdditionalItems")
+		}
+	}
+
+	if schema.Items != nil {
+		if schema.Items.SchemaArray != nil {
+			for _, s := range *(schema.Items.SchemaArray) {
+				s.applyToSchemas(operation, "Items.SchemaArray")
+			}
+		} else if schema.Items.Schema != nil {
+			schema.Items.Schema.applyToSchemas(operation, "Items.Schema")
+		}
+	}
+
+	if schema.AdditionalProperties != nil {
+		s := schema.AdditionalProperties.Schema
+		if s != nil {
+			s.applyToSchemas(operation, "AdditionalProperties")
+		}
+	}
+
+	if schema.Properties != nil {
+		for _, pair := range *(schema.Properties) {
+			s := pair.Value
+			s.applyToSchemas(operation, "Properties")
+		}
+	}
+	if schema.PatternProperties != nil {
+		for _, pair := range *(schema.PatternProperties) {
+			s := pair.Value
+			s.applyToSchemas(operation, "PatternProperties")
+		}
+	}
+
+	if schema.Dependencies != nil {
+		for _, pair := range *(schema.Dependencies) {
+			schemaOrStringArray := pair.Value
+			s := schemaOrStringArray.Schema
+			if s != nil {
+				s.applyToSchemas(operation, "Dependencies")
+			}
+		}
+	}
+
+	if schema.AllOf != nil {
+		for _, s := range *(schema.AllOf) {
+			s.applyToSchemas(operation, "AllOf")
+		}
+	}
+	if schema.AnyOf != nil {
+		for _, s := range *(schema.AnyOf) {
+			s.applyToSchemas(operation, "AnyOf")
+		}
+	}
+	if schema.OneOf != nil {
+		for _, s := range *(schema.OneOf) {
+			s.applyToSchemas(operation, "OneOf")
+		}
+	}
+	if schema.Not != nil {
+		schema.Not.applyToSchemas(operation, "Not")
+	}
+
+	if schema.Definitions != nil {
+		for _, pair := range *(schema.Definitions) {
+			s := pair.Value
+			s.applyToSchemas(operation, "Definitions")
+		}
+	}
+
+	operation(schema, context)
+}
+
+// CopyProperties copies all non-nil properties from the source Schema to the schema Schema.
+func (schema *Schema) CopyProperties(source *Schema) {
+	if source.Schema != nil {
+		schema.Schema = source.Schema
+	}
+	if source.ID != nil {
+		schema.ID = source.ID
+	}
+	if source.MultipleOf != nil {
+		schema.MultipleOf = source.MultipleOf
+	}
+	if source.Maximum != nil {
+		schema.Maximum = source.Maximum
+	}
+	if source.ExclusiveMaximum != nil {
+		schema.ExclusiveMaximum = source.ExclusiveMaximum
+	}
+	if source.Minimum != nil {
+		schema.Minimum = source.Minimum
+	}
+	if source.ExclusiveMinimum != nil {
+		schema.ExclusiveMinimum = source.ExclusiveMinimum
+	}
+	if source.MaxLength != nil {
+		schema.MaxLength = source.MaxLength
+	}
+	if source.MinLength != nil {
+		schema.MinLength = source.MinLength
+	}
+	if source.Pattern != nil {
+		schema.Pattern = source.Pattern
+	}
+	if source.AdditionalItems != nil {
+		schema.AdditionalItems = source.AdditionalItems
+	}
+	if source.Items != nil {
+		schema.Items = source.Items
+	}
+	if source.MaxItems != nil {
+		schema.MaxItems = source.MaxItems
+	}
+	if source.MinItems != nil {
+		schema.MinItems = source.MinItems
+	}
+	if source.UniqueItems != nil {
+		schema.UniqueItems = source.UniqueItems
+	}
+	if source.MaxProperties != nil {
+		schema.MaxProperties = source.MaxProperties
+	}
+	if source.MinProperties != nil {
+		schema.MinProperties = source.MinProperties
+	}
+	if source.Required != nil {
+		schema.Required = source.Required
+	}
+	if source.AdditionalProperties != nil {
+		schema.AdditionalProperties = source.AdditionalProperties
+	}
+	if source.Properties != nil {
+		schema.Properties = source.Properties
+	}
+	if source.PatternProperties != nil {
+		schema.PatternProperties = source.PatternProperties
+	}
+	if source.Dependencies != nil {
+		schema.Dependencies = source.Dependencies
+	}
+	if source.Enumeration != nil {
+		schema.Enumeration = source.Enumeration
+	}
+	if source.Type != nil {
+		schema.Type = source.Type
+	}
+	if source.AllOf != nil {
+		schema.AllOf = source.AllOf
+	}
+	if source.AnyOf != nil {
+		schema.AnyOf = source.AnyOf
+	}
+	if source.OneOf != nil {
+		schema.OneOf = source.OneOf
+	}
+	if source.Not != nil {
+		schema.Not = source.Not
+	}
+	if source.Definitions != nil {
+		schema.Definitions = source.Definitions
+	}
+	if source.Title != nil {
+		schema.Title = source.Title
+	}
+	if source.Description != nil {
+		schema.Description = source.Description
+	}
+	if source.Default != nil {
+		schema.Default = source.Default
+	}
+	if source.Format != nil {
+		schema.Format = source.Format
+	}
+	if source.Ref != nil {
+		schema.Ref = source.Ref
+	}
+}
+
+// TypeIs returns true if the Type of a Schema includes the specified type
+func (schema *Schema) TypeIs(typeName string) bool {
+	if schema.Type != nil {
+		// the schema Type is either a string or an array of strings
+		if schema.Type.String != nil {
+			return (*(schema.Type.String) == typeName)
+		} else if schema.Type.StringArray != nil {
+			for _, n := range *(schema.Type.StringArray) {
+				if n == typeName {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+// ResolveRefs resolves "$ref" elements in a Schema and its children.
+// But if a reference refers to an object type, is inside a oneOf, or contains a oneOf,
+// the reference is kept and we expect downstream tools to separately model these
+// referenced schemas.
+func (schema *Schema) ResolveRefs() {
+	rootSchema := schema
+	count := 1
+	for count > 0 {
+		count = 0
+		schema.applyToSchemas(
+			func(schema *Schema, context string) {
+				if schema.Ref != nil {
+					resolvedRef, err := rootSchema.resolveJSONPointer(*(schema.Ref))
+					if err != nil {
+						log.Printf("%+v", err)
+					} else if resolvedRef.TypeIs("object") {
+						// don't substitute for objects, we'll model the referenced schema with a class
+					} else if context == "OneOf" {
+						// don't substitute for references inside oneOf declarations
+					} else if resolvedRef.OneOf != nil {
+						// don't substitute for references that contain oneOf declarations
+					} else if resolvedRef.AdditionalProperties != nil {
+						// don't substitute for references that look like objects
+					} else {
+						schema.Ref = nil
+						schema.CopyProperties(resolvedRef)
+						count++
+					}
+				}
+			}, "")
+	}
+}
+
+// resolveJSONPointer resolves JSON pointers.
+// This current implementation is very crude and custom for OpenAPI 2.0 schemas.
+// It panics for any pointer that it is unable to resolve.
+func (schema *Schema) resolveJSONPointer(ref string) (result *Schema, err error) {
+	parts := strings.Split(ref, "#")
+	if len(parts) == 2 {
+		documentName := parts[0] + "#"
+		if documentName == "#" && schema.ID != nil {
+			documentName = *(schema.ID)
+		}
+		path := parts[1]
+		document := schemas[documentName]
+		pathParts := strings.Split(path, "/")
+
+		// we currently do a very limited (hard-coded) resolution of certain paths and log errors for missed cases
+		if len(pathParts) == 1 {
+			return document, nil
+		} else if len(pathParts) == 3 {
+			switch pathParts[1] {
+			case "definitions":
+				dictionary := document.Definitions
+				for _, pair := range *dictionary {
+					if pair.Name == pathParts[2] {
+						result = pair.Value
+					}
+				}
+			case "properties":
+				dictionary := document.Properties
+				for _, pair := range *dictionary {
+					if pair.Name == pathParts[2] {
+						result = pair.Value
+					}
+				}
+			default:
+				break
+			}
+		}
+	}
+	if result == nil {
+		return nil, fmt.Errorf("unresolved pointer: %+v", ref)
+	}
+	return result, nil
+}
+
+// ResolveAllOfs replaces "allOf" elements by merging their properties into the parent Schema.
+func (schema *Schema) ResolveAllOfs() {
+	schema.applyToSchemas(
+		func(schema *Schema, context string) {
+			if schema.AllOf != nil {
+				for _, allOf := range *(schema.AllOf) {
+					schema.CopyProperties(allOf)
+				}
+				schema.AllOf = nil
+			}
+		}, "resolveAllOfs")
+}
+
+// ResolveAnyOfs replaces all "anyOf" elements with "oneOf".
+func (schema *Schema) ResolveAnyOfs() {
+	schema.applyToSchemas(
+		func(schema *Schema, context string) {
+			if schema.AnyOf != nil {
+				schema.OneOf = schema.AnyOf
+				schema.AnyOf = nil
+			}
+		}, "resolveAnyOfs")
+}
+
+// return a pointer to a copy of a passed-in string
+func stringptr(input string) (output *string) {
+	return &input
+}
+
+// CopyOfficialSchemaProperty copies a named property from the official JSON Schema definition
+func (schema *Schema) CopyOfficialSchemaProperty(name string) {
+	*schema.Properties = append(*schema.Properties,
+		NewNamedSchema(name,
+			&Schema{Ref: stringptr("http://json-schema.org/draft-04/schema#/properties/" + name)}))
+}
+
+// CopyOfficialSchemaProperties copies named properties from the official JSON Schema definition
+func (schema *Schema) CopyOfficialSchemaProperties(names []string) {
+	for _, name := range names {
+		schema.CopyOfficialSchemaProperty(name)
+	}
+}

vendor/github.com/google/gnostic/jsonschema/reader.go

@@ -0,0 +1,442 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// 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.
+
+//go:generate go run generate-base.go
+
+package jsonschema
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strconv"
+
+	"gopkg.in/yaml.v3"
+)
+
+// This is a global map of all known Schemas.
+// It is initialized when the first Schema is created and inserted.
+var schemas map[string]*Schema
+
+// NewBaseSchema builds a schema object from an embedded json representation.
+func NewBaseSchema() (schema *Schema, err error) {
+	b, err := baseSchemaBytes()
+	if err != nil {
+		return nil, err
+	}
+	var node yaml.Node
+	err = yaml.Unmarshal(b, &node)
+	if err != nil {
+		return nil, err
+	}
+	return NewSchemaFromObject(&node), nil
+}
+
+// NewSchemaFromFile reads a schema from a file.
+// Currently this assumes that schemas are stored in the source distribution of this project.
+func NewSchemaFromFile(filename string) (schema *Schema, err error) {
+	file, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	var node yaml.Node
+	err = yaml.Unmarshal(file, &node)
+	if err != nil {
+		return nil, err
+	}
+	return NewSchemaFromObject(&node), nil
+}
+
+// NewSchemaFromObject constructs a schema from a parsed JSON object.
+// Due to the complexity of the schema representation, this is a
+// custom reader and not the standard Go JSON reader (encoding/json).
+func NewSchemaFromObject(jsonData *yaml.Node) *Schema {
+	switch jsonData.Kind {
+	case yaml.DocumentNode:
+		return NewSchemaFromObject(jsonData.Content[0])
+	case yaml.MappingNode:
+		schema := &Schema{}
+
+		for i := 0; i < len(jsonData.Content); i += 2 {
+			k := jsonData.Content[i].Value
+			v := jsonData.Content[i+1]
+
+			switch k {
+			case "$schema":
+				schema.Schema = schema.stringValue(v)
+			case "id":
+				schema.ID = schema.stringValue(v)
+
+			case "multipleOf":
+				schema.MultipleOf = schema.numberValue(v)
+			case "maximum":
+				schema.Maximum = schema.numberValue(v)
+			case "exclusiveMaximum":
+				schema.ExclusiveMaximum = schema.boolValue(v)
+			case "minimum":
+				schema.Minimum = schema.numberValue(v)
+			case "exclusiveMinimum":
+				schema.ExclusiveMinimum = schema.boolValue(v)
+
+			case "maxLength":
+				schema.MaxLength = schema.intValue(v)
+			case "minLength":
+				schema.MinLength = schema.intValue(v)
+			case "pattern":
+				schema.Pattern = schema.stringValue(v)
+
+			case "additionalItems":
+				schema.AdditionalItems = schema.schemaOrBooleanValue(v)
+			case "items":
+				schema.Items = schema.schemaOrSchemaArrayValue(v)
+			case "maxItems":
+				schema.MaxItems = schema.intValue(v)
+			case "minItems":
+				schema.MinItems = schema.intValue(v)
+			case "uniqueItems":
+				schema.UniqueItems = schema.boolValue(v)
+
+			case "maxProperties":
+				schema.MaxProperties = schema.intValue(v)
+			case "minProperties":
+				schema.MinProperties = schema.intValue(v)
+			case "required":
+				schema.Required = schema.arrayOfStringsValue(v)
+			case "additionalProperties":
+				schema.AdditionalProperties = schema.schemaOrBooleanValue(v)
+			case "properties":
+				schema.Properties = schema.mapOfSchemasValue(v)
+			case "patternProperties":
+				schema.PatternProperties = schema.mapOfSchemasValue(v)
+			case "dependencies":
+				schema.Dependencies = schema.mapOfSchemasOrStringArraysValue(v)
+
+			case "enum":
+				schema.Enumeration = schema.arrayOfEnumValuesValue(v)
+
+			case "type":
+				schema.Type = schema.stringOrStringArrayValue(v)
+			case "allOf":
+				schema.AllOf = schema.arrayOfSchemasValue(v)
+			case "anyOf":
+				schema.AnyOf = schema.arrayOfSchemasValue(v)
+			case "oneOf":
+				schema.OneOf = schema.arrayOfSchemasValue(v)
+			case "not":
+				schema.Not = NewSchemaFromObject(v)
+			case "definitions":
+				schema.Definitions = schema.mapOfSchemasValue(v)
+
+			case "title":
+				schema.Title = schema.stringValue(v)
+			case "description":
+				schema.Description = schema.stringValue(v)
+
+			case "default":
+				schema.Default = v
+
+			case "format":
+				schema.Format = schema.stringValue(v)
+			case "$ref":
+				schema.Ref = schema.stringValue(v)
+			default:
+				fmt.Printf("UNSUPPORTED (%s)\n", k)
+			}
+		}
+
+		// insert schema in global map
+		if schema.ID != nil {
+			if schemas == nil {
+				schemas = make(map[string]*Schema, 0)
+			}
+			schemas[*(schema.ID)] = schema
+		}
+		return schema
+
+	default:
+		fmt.Printf("schemaValue: unexpected node %+v\n", jsonData)
+		return nil
+	}
+
+	return nil
+}
+
+//
+// BUILDERS
+// The following methods build elements of Schemas from interface{} values.
+// Each returns nil if it is unable to build the desired element.
+//
+
+// Gets the string value of an interface{} value if possible.
+func (schema *Schema) stringValue(v *yaml.Node) *string {
+	switch v.Kind {
+	case yaml.ScalarNode:
+		return &v.Value
+	default:
+		fmt.Printf("stringValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets the numeric value of an interface{} value if possible.
+func (schema *Schema) numberValue(v *yaml.Node) *SchemaNumber {
+	number := &SchemaNumber{}
+	switch v.Kind {
+	case yaml.ScalarNode:
+		switch v.Tag {
+		case "!!float":
+			v2, _ := strconv.ParseFloat(v.Value, 64)
+			number.Float = &v2
+			return number
+		case "!!int":
+			v2, _ := strconv.ParseInt(v.Value, 10, 64)
+			number.Integer = &v2
+			return number
+		default:
+			fmt.Printf("stringValue: unexpected node %+v\n", v)
+		}
+	default:
+		fmt.Printf("stringValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets the integer value of an interface{} value if possible.
+func (schema *Schema) intValue(v *yaml.Node) *int64 {
+	switch v.Kind {
+	case yaml.ScalarNode:
+		switch v.Tag {
+		case "!!float":
+			v2, _ := strconv.ParseFloat(v.Value, 64)
+			v3 := int64(v2)
+			return &v3
+		case "!!int":
+			v2, _ := strconv.ParseInt(v.Value, 10, 64)
+			return &v2
+		default:
+			fmt.Printf("intValue: unexpected node %+v\n", v)
+		}
+	default:
+		fmt.Printf("intValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets the bool value of an interface{} value if possible.
+func (schema *Schema) boolValue(v *yaml.Node) *bool {
+	switch v.Kind {
+	case yaml.ScalarNode:
+		switch v.Tag {
+		case "!!bool":
+			v2, _ := strconv.ParseBool(v.Value)
+			return &v2
+		default:
+			fmt.Printf("boolValue: unexpected node %+v\n", v)
+		}
+	default:
+		fmt.Printf("boolValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets a map of Schemas from an interface{} value if possible.
+func (schema *Schema) mapOfSchemasValue(v *yaml.Node) *[]*NamedSchema {
+	switch v.Kind {
+	case yaml.MappingNode:
+		m := make([]*NamedSchema, 0)
+		for i := 0; i < len(v.Content); i += 2 {
+			k2 := v.Content[i].Value
+			v2 := v.Content[i+1]
+			pair := &NamedSchema{Name: k2, Value: NewSchemaFromObject(v2)}
+			m = append(m, pair)
+		}
+		return &m
+	default:
+		fmt.Printf("mapOfSchemasValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets an array of Schemas from an interface{} value if possible.
+func (schema *Schema) arrayOfSchemasValue(v *yaml.Node) *[]*Schema {
+	switch v.Kind {
+	case yaml.SequenceNode:
+		m := make([]*Schema, 0)
+		for _, v2 := range v.Content {
+			switch v2.Kind {
+			case yaml.MappingNode:
+				s := NewSchemaFromObject(v2)
+				m = append(m, s)
+			default:
+				fmt.Printf("arrayOfSchemasValue: unexpected node %+v\n", v2)
+			}
+		}
+		return &m
+	case yaml.MappingNode:
+		m := make([]*Schema, 0)
+		s := NewSchemaFromObject(v)
+		m = append(m, s)
+		return &m
+	default:
+		fmt.Printf("arrayOfSchemasValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets a Schema or an array of Schemas from an interface{} value if possible.
+func (schema *Schema) schemaOrSchemaArrayValue(v *yaml.Node) *SchemaOrSchemaArray {
+	switch v.Kind {
+	case yaml.SequenceNode:
+		m := make([]*Schema, 0)
+		for _, v2 := range v.Content {
+			switch v2.Kind {
+			case yaml.MappingNode:
+				s := NewSchemaFromObject(v2)
+				m = append(m, s)
+			default:
+				fmt.Printf("schemaOrSchemaArrayValue: unexpected node %+v\n", v2)
+			}
+		}
+		return &SchemaOrSchemaArray{SchemaArray: &m}
+	case yaml.MappingNode:
+		s := NewSchemaFromObject(v)
+		return &SchemaOrSchemaArray{Schema: s}
+	default:
+		fmt.Printf("schemaOrSchemaArrayValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets an array of strings from an interface{} value if possible.
+func (schema *Schema) arrayOfStringsValue(v *yaml.Node) *[]string {
+	switch v.Kind {
+	case yaml.ScalarNode:
+		a := []string{v.Value}
+		return &a
+	case yaml.SequenceNode:
+		a := make([]string, 0)
+		for _, v2 := range v.Content {
+			switch v2.Kind {
+			case yaml.ScalarNode:
+				a = append(a, v2.Value)
+			default:
+				fmt.Printf("arrayOfStringsValue: unexpected node %+v\n", v2)
+			}
+		}
+		return &a
+	default:
+		fmt.Printf("arrayOfStringsValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets a string or an array of strings from an interface{} value if possible.
+func (schema *Schema) stringOrStringArrayValue(v *yaml.Node) *StringOrStringArray {
+	switch v.Kind {
+	case yaml.ScalarNode:
+		s := &StringOrStringArray{}
+		s.String = &v.Value
+		return s
+	case yaml.SequenceNode:
+		a := make([]string, 0)
+		for _, v2 := range v.Content {
+			switch v2.Kind {
+			case yaml.ScalarNode:
+				a = append(a, v2.Value)
+			default:
+				fmt.Printf("arrayOfStringsValue: unexpected node %+v\n", v2)
+			}
+		}
+		s := &StringOrStringArray{}
+		s.StringArray = &a
+		return s
+	default:
+		fmt.Printf("arrayOfStringsValue: unexpected node %+v\n", v)
+	}
+	return nil
+}
+
+// Gets an array of enum values from an interface{} value if possible.
+func (schema *Schema) arrayOfEnumValuesValue(v *yaml.Node) *[]SchemaEnumValue {
+	a := make([]SchemaEnumValue, 0)
+	switch v.Kind {
+	case yaml.SequenceNode:
+		for _, v2 := range v.Content {
+			switch v2.Kind {
+			case yaml.ScalarNode:
+				switch v2.Tag {
+				case "!!str":
+					a = append(a, SchemaEnumValue{String: &v2.Value})
+				case "!!bool":
+					v3, _ := strconv.ParseBool(v2.Value)
+					a = append(a, SchemaEnumValue{Bool: &v3})
+				default:
+					fmt.Printf("arrayOfEnumValuesValue: unexpected type %s\n", v2.Tag)
+				}
+			default:
+				fmt.Printf("arrayOfEnumValuesValue: unexpected node %+v\n", v2)
+			}
+		}
+	default:
+		fmt.Printf("arrayOfEnumValuesValue: unexpected node %+v\n", v)
+	}
+	return &a
+}
+
+// Gets a map of schemas or string arrays from an interface{} value if possible.
+func (schema *Schema) mapOfSchemasOrStringArraysValue(v *yaml.Node) *[]*NamedSchemaOrStringArray {
+	m := make([]*NamedSchemaOrStringArray, 0)
+	switch v.Kind {
+	case yaml.MappingNode:
+		for i := 0; i < len(v.Content); i += 2 {
+			k2 := v.Content[i].Value
+			v2 := v.Content[i+1]
+			switch v2.Kind {
+			case yaml.SequenceNode:
+				a := make([]string, 0)
+				for _, v3 := range v2.Content {
+					switch v3.Kind {
+					case yaml.ScalarNode:
+						a = append(a, v3.Value)
+					default:
+						fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected node %+v\n", v3)
+					}
+				}
+				s := &SchemaOrStringArray{}
+				s.StringArray = &a
+				pair := &NamedSchemaOrStringArray{Name: k2, Value: s}
+				m = append(m, pair)
+			default:
+				fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected node %+v\n", v2)
+			}
+		}
+	default:
+		fmt.Printf("mapOfSchemasOrStringArraysValue: unexpected node %+v\n", v)
+	}
+	return &m
+}
+
+// Gets a schema or a boolean value from an interface{} value if possible.
+func (schema *Schema) schemaOrBooleanValue(v *yaml.Node) *SchemaOrBoolean {
+	schemaOrBoolean := &SchemaOrBoolean{}
+	switch v.Kind {
+	case yaml.ScalarNode:
+		v2, _ := strconv.ParseBool(v.Value)
+		schemaOrBoolean.Boolean = &v2
+	case yaml.MappingNode:
+		schemaOrBoolean.Schema = NewSchemaFromObject(v)
+	default:
+		fmt.Printf("schemaOrBooleanValue: unexpected node %+v\n", v)
+	}
+	return schemaOrBoolean
+}

vendor/github.com/google/gnostic/jsonschema/schema.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

vendor/github.com/google/gnostic/jsonschema/writer.go

@@ -0,0 +1,369 @@
+// Copyright 2017 Google LLC. All Rights Reserved.
+//
+// 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 jsonschema
+
+import (
+	"fmt"
+
+	"gopkg.in/yaml.v3"
+)
+
+const indentation = "  "
+
+func renderMappingNode(node *yaml.Node, indent string) (result string) {
+	result = "{\n"
+	innerIndent := indent + indentation
+	for i := 0; i < len(node.Content); i += 2 {
+		// first print the key
+		key := node.Content[i].Value
+		result += fmt.Sprintf("%s\"%+v\": ", innerIndent, key)
+		// then the value
+		value := node.Content[i+1]
+		switch value.Kind {
+		case yaml.ScalarNode:
+			result += "\"" + value.Value + "\""
+		case yaml.MappingNode:
+			result += renderMappingNode(value, innerIndent)
+		case yaml.SequenceNode:
+			result += renderSequenceNode(value, innerIndent)
+		default:
+			result += fmt.Sprintf("???MapItem(Key:%+v, Value:%T)", value, value)
+		}
+		if i < len(node.Content)-2 {
+			result += ","
+		}
+		result += "\n"
+	}
+
+	result += indent + "}"
+	return result
+}
+
+func renderSequenceNode(node *yaml.Node, indent string) (result string) {
+	result = "[\n"
+	innerIndent := indent + indentation
+	for i := 0; i < len(node.Content); i++ {
+		item := node.Content[i]
+		switch item.Kind {
+		case yaml.ScalarNode:
+			result += innerIndent + "\"" + item.Value + "\""
+		case yaml.MappingNode:
+			result += innerIndent + renderMappingNode(item, innerIndent) + ""
+		default:
+			result += innerIndent + fmt.Sprintf("???ArrayItem(%+v)", item)
+		}
+		if i < len(node.Content)-1 {
+			result += ","
+		}
+		result += "\n"
+	}
+	result += indent + "]"
+	return result
+}
+
+func renderStringArray(array []string, indent string) (result string) {
+	result = "[\n"
+	innerIndent := indent + indentation
+	for i, item := range array {
+		result += innerIndent + "\"" + item + "\""
+		if i < len(array)-1 {
+			result += ","
+		}
+		result += "\n"
+	}
+	result += indent + "]"
+	return result
+}
+
+// Render renders a yaml.Node as JSON
+func Render(node *yaml.Node) string {
+	if node.Kind == yaml.DocumentNode {
+		if len(node.Content) == 1 {
+			return Render(node.Content[0])
+		}
+	} else if node.Kind == yaml.MappingNode {
+		return renderMappingNode(node, "") + "\n"
+	} else if node.Kind == yaml.SequenceNode {
+		return renderSequenceNode(node, "") + "\n"
+	}
+	return ""
+}
+
+func (object *SchemaNumber) nodeValue() *yaml.Node {
+	if object.Integer != nil {
+		return nodeForInt64(*object.Integer)
+	} else if object.Float != nil {
+		return nodeForFloat64(*object.Float)
+	} else {
+		return nil
+	}
+}
+
+func (object *SchemaOrBoolean) nodeValue() *yaml.Node {
+	if object.Schema != nil {
+		return object.Schema.nodeValue()
+	} else if object.Boolean != nil {
+		return nodeForBoolean(*object.Boolean)
+	} else {
+		return nil
+	}
+}
+
+func nodeForStringArray(array []string) *yaml.Node {
+	content := make([]*yaml.Node, 0)
+	for _, item := range array {
+		content = append(content, nodeForString(item))
+	}
+	return nodeForSequence(content)
+}
+
+func nodeForSchemaArray(array []*Schema) *yaml.Node {
+	content := make([]*yaml.Node, 0)
+	for _, item := range array {
+		content = append(content, item.nodeValue())
+	}
+	return nodeForSequence(content)
+}
+
+func (object *StringOrStringArray) nodeValue() *yaml.Node {
+	if object.String != nil {
+		return nodeForString(*object.String)
+	} else if object.StringArray != nil {
+		return nodeForStringArray(*(object.StringArray))
+	} else {
+		return nil
+	}
+}
+
+func (object *SchemaOrStringArray) nodeValue() *yaml.Node {
+	if object.Schema != nil {
+		return object.Schema.nodeValue()
+	} else if object.StringArray != nil {
+		return nodeForStringArray(*(object.StringArray))
+	} else {
+		return nil
+	}
+}
+
+func (object *SchemaOrSchemaArray) nodeValue() *yaml.Node {
+	if object.Schema != nil {
+		return object.Schema.nodeValue()
+	} else if object.SchemaArray != nil {
+		return nodeForSchemaArray(*(object.SchemaArray))
+	} else {
+		return nil
+	}
+}
+
+func (object *SchemaEnumValue) nodeValue() *yaml.Node {
+	if object.String != nil {
+		return nodeForString(*object.String)
+	} else if object.Bool != nil {
+		return nodeForBoolean(*object.Bool)
+	} else {
+		return nil
+	}
+}
+
+func nodeForNamedSchemaArray(array *[]*NamedSchema) *yaml.Node {
+	content := make([]*yaml.Node, 0)
+	for _, pair := range *(array) {
+		content = appendPair(content, pair.Name, pair.Value.nodeValue())
+	}
+	return nodeForMapping(content)
+}
+
+func nodeForNamedSchemaOrStringArray(array *[]*NamedSchemaOrStringArray) *yaml.Node {
+	content := make([]*yaml.Node, 0)
+	for _, pair := range *(array) {
+		content = appendPair(content, pair.Name, pair.Value.nodeValue())
+	}
+	return nodeForMapping(content)
+}
+
+func nodeForSchemaEnumArray(array *[]SchemaEnumValue) *yaml.Node {
+	content := make([]*yaml.Node, 0)
+	for _, item := range *array {
+		content = append(content, item.nodeValue())
+	}
+	return nodeForSequence(content)
+}
+
+func nodeForMapping(content []*yaml.Node) *yaml.Node {
+	return &yaml.Node{
+		Kind:    yaml.MappingNode,
+		Content: content,
+	}
+}
+
+func nodeForSequence(content []*yaml.Node) *yaml.Node {
+	return &yaml.Node{
+		Kind:    yaml.SequenceNode,
+		Content: content,
+	}
+}
+
+func nodeForString(value string) *yaml.Node {
+	return &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Tag:   "!!str",
+		Value: value,
+	}
+}
+
+func nodeForBoolean(value bool) *yaml.Node {
+	return &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Tag:   "!!bool",
+		Value: fmt.Sprintf("%t", value),
+	}
+}
+
+func nodeForInt64(value int64) *yaml.Node {
+	return &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Tag:   "!!int",
+		Value: fmt.Sprintf("%d", value),
+	}
+}
+
+func nodeForFloat64(value float64) *yaml.Node {
+	return &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Tag:   "!!float",
+		Value: fmt.Sprintf("%f", value),
+	}
+}
+
+func appendPair(nodes []*yaml.Node, name string, value *yaml.Node) []*yaml.Node {
+	nodes = append(nodes, nodeForString(name))
+	nodes = append(nodes, value)
+	return nodes
+}
+
+func (schema *Schema) nodeValue() *yaml.Node {
+	n := &yaml.Node{Kind: yaml.MappingNode}
+	content := make([]*yaml.Node, 0)
+	if schema.Title != nil {
+		content = appendPair(content, "title", nodeForString(*schema.Title))
+	}
+	if schema.ID != nil {
+		content = appendPair(content, "id", nodeForString(*schema.ID))
+	}
+	if schema.Schema != nil {
+		content = appendPair(content, "$schema", nodeForString(*schema.Schema))
+	}
+	if schema.Type != nil {
+		content = appendPair(content, "type", schema.Type.nodeValue())
+	}
+	if schema.Items != nil {
+		content = appendPair(content, "items", schema.Items.nodeValue())
+	}
+	if schema.Description != nil {
+		content = appendPair(content, "description", nodeForString(*schema.Description))
+	}
+	if schema.Required != nil {
+		content = appendPair(content, "required", nodeForStringArray(*schema.Required))
+	}
+	if schema.AdditionalProperties != nil {
+		content = appendPair(content, "additionalProperties", schema.AdditionalProperties.nodeValue())
+	}
+	if schema.PatternProperties != nil {
+		content = appendPair(content, "patternProperties", nodeForNamedSchemaArray(schema.PatternProperties))
+	}
+	if schema.Properties != nil {
+		content = appendPair(content, "properties", nodeForNamedSchemaArray(schema.Properties))
+	}
+	if schema.Dependencies != nil {
+		content = appendPair(content, "dependencies", nodeForNamedSchemaOrStringArray(schema.Dependencies))
+	}
+	if schema.Ref != nil {
+		content = appendPair(content, "$ref", nodeForString(*schema.Ref))
+	}
+	if schema.MultipleOf != nil {
+		content = appendPair(content, "multipleOf", schema.MultipleOf.nodeValue())
+	}
+	if schema.Maximum != nil {
+		content = appendPair(content, "maximum", schema.Maximum.nodeValue())
+	}
+	if schema.ExclusiveMaximum != nil {
+		content = appendPair(content, "exclusiveMaximum", nodeForBoolean(*schema.ExclusiveMaximum))
+	}
+	if schema.Minimum != nil {
+		content = appendPair(content, "minimum", schema.Minimum.nodeValue())
+	}
+	if schema.ExclusiveMinimum != nil {
+		content = appendPair(content, "exclusiveMinimum", nodeForBoolean(*schema.ExclusiveMinimum))
+	}
+	if schema.MaxLength != nil {
+		content = appendPair(content, "maxLength", nodeForInt64(*schema.MaxLength))
+	}
+	if schema.MinLength != nil {
+		content = appendPair(content, "minLength", nodeForInt64(*schema.MinLength))
+	}
+	if schema.Pattern != nil {
+		content = appendPair(content, "pattern", nodeForString(*schema.Pattern))
+	}
+	if schema.AdditionalItems != nil {
+		content = appendPair(content, "additionalItems", schema.AdditionalItems.nodeValue())
+	}
+	if schema.MaxItems != nil {
+		content = appendPair(content, "maxItems", nodeForInt64(*schema.MaxItems))
+	}
+	if schema.MinItems != nil {
+		content = appendPair(content, "minItems", nodeForInt64(*schema.MinItems))
+	}
+	if schema.UniqueItems != nil {
+		content = appendPair(content, "uniqueItems", nodeForBoolean(*schema.UniqueItems))
+	}
+	if schema.MaxProperties != nil {
+		content = appendPair(content, "maxProperties", nodeForInt64(*schema.MaxProperties))
+	}
+	if schema.MinProperties != nil {
+		content = appendPair(content, "minProperties", nodeForInt64(*schema.MinProperties))
+	}
+	if schema.Enumeration != nil {
+		content = appendPair(content, "enum", nodeForSchemaEnumArray(schema.Enumeration))
+	}
+	if schema.AllOf != nil {
+		content = appendPair(content, "allOf", nodeForSchemaArray(*schema.AllOf))
+	}
+	if schema.AnyOf != nil {
+		content = appendPair(content, "anyOf", nodeForSchemaArray(*schema.AnyOf))
+	}
+	if schema.OneOf != nil {
+		content = appendPair(content, "oneOf", nodeForSchemaArray(*schema.OneOf))
+	}
+	if schema.Not != nil {
+		content = appendPair(content, "not", schema.Not.nodeValue())
+	}
+	if schema.Definitions != nil {
+		content = appendPair(content, "definitions", nodeForNamedSchemaArray(schema.Definitions))
+	}
+	if schema.Default != nil {
+		// m = append(m, yaml.MapItem{Key: "default", Value: *schema.Default})
+	}
+	if schema.Format != nil {
+		content = appendPair(content, "format", nodeForString(*schema.Format))
+	}
+	n.Content = content
+	return n
+}
+
+// JSONString returns a json representation of a schema.
+func (schema *Schema) JSONString() string {
+	node := schema.nodeValue()
+	return Render(node)
+}