[chore] remove vendor

1 files changed, 0 insertions, 645 deletions

diff --git a/vendor/github.com/go-openapi/spec/schema.go b/vendor/github.com/go-openapi/spec/schema.go
deleted file mode 100644
index 4e9be8576..000000000
--- a/vendor/github.com/go-openapi/spec/schema.go
+++ /dev/null
@@ -1,645 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package spec
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/go-openapi/jsonpointer"
-	"github.com/go-openapi/swag"
-)
-
-// BooleanProperty creates a boolean property
-func BooleanProperty() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"boolean"}}}
-}
-
-// BoolProperty creates a boolean property
-func BoolProperty() *Schema { return BooleanProperty() }
-
-// StringProperty creates a string property
-func StringProperty() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
-}
-
-// CharProperty creates a string property
-func CharProperty() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
-}
-
-// Float64Property creates a float64/double property
-func Float64Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "double"}}
-}
-
-// Float32Property creates a float32/float property
-func Float32Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "float"}}
-}
-
-// Int8Property creates an int8 property
-func Int8Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int8"}}
-}
-
-// Int16Property creates an int16 property
-func Int16Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int16"}}
-}
-
-// Int32Property creates an int32 property
-func Int32Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int32"}}
-}
-
-// Int64Property creates an int64 property
-func Int64Property() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}}
-}
-
-// StrFmtProperty creates a property for the named string format
-func StrFmtProperty(format string) *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: format}}
-}
-
-// DateProperty creates a date property
-func DateProperty() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date"}}
-}
-
-// DateTimeProperty creates a date time property
-func DateTimeProperty() *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date-time"}}
-}
-
-// MapProperty creates a map property
-func MapProperty(property *Schema) *Schema {
-	return &Schema{SchemaProps: SchemaProps{Type: []string{"object"},
-		AdditionalProperties: &SchemaOrBool{Allows: true, Schema: property}}}
-}
-
-// RefProperty creates a ref property
-func RefProperty(name string) *Schema {
-	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
-}
-
-// RefSchema creates a ref property
-func RefSchema(name string) *Schema {
-	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
-}
-
-// ArrayProperty creates an array property
-func ArrayProperty(items *Schema) *Schema {
-	if items == nil {
-		return &Schema{SchemaProps: SchemaProps{Type: []string{"array"}}}
-	}
-	return &Schema{SchemaProps: SchemaProps{Items: &SchemaOrArray{Schema: items}, Type: []string{"array"}}}
-}
-
-// ComposedSchema creates a schema with allOf
-func ComposedSchema(schemas ...Schema) *Schema {
-	s := new(Schema)
-	s.AllOf = schemas
-	return s
-}
-
-// SchemaURL represents a schema url
-type SchemaURL string
-
-// MarshalJSON marshal this to JSON
-func (r SchemaURL) MarshalJSON() ([]byte, error) {
-	if r == "" {
-		return []byte("{}"), nil
-	}
-	v := map[string]interface{}{"$schema": string(r)}
-	return json.Marshal(v)
-}
-
-// UnmarshalJSON unmarshal this from JSON
-func (r *SchemaURL) UnmarshalJSON(data []byte) error {
-	var v map[string]interface{}
-	if err := json.Unmarshal(data, &v); err != nil {
-		return err
-	}
-	return r.fromMap(v)
-}
-
-func (r *SchemaURL) fromMap(v map[string]interface{}) error {
-	if v == nil {
-		return nil
-	}
-	if vv, ok := v["$schema"]; ok {
-		if str, ok := vv.(string); ok {
-			u, err := parseURL(str)
-			if err != nil {
-				return err
-			}
-
-			*r = SchemaURL(u.String())
-		}
-	}
-	return nil
-}
-
-// SchemaProps describes a JSON schema (draft 4)
-type SchemaProps struct {
-	ID                   string           `json:"id,omitempty"`
-	Ref                  Ref              `json:"-"`
-	Schema               SchemaURL        `json:"-"`
-	Description          string           `json:"description,omitempty"`
-	Type                 StringOrArray    `json:"type,omitempty"`
-	Nullable             bool             `json:"nullable,omitempty"`
-	Format               string           `json:"format,omitempty"`
-	Title                string           `json:"title,omitempty"`
-	Default              interface{}      `json:"default,omitempty"`
-	Maximum              *float64         `json:"maximum,omitempty"`
-	ExclusiveMaximum     bool             `json:"exclusiveMaximum,omitempty"`
-	Minimum              *float64         `json:"minimum,omitempty"`
-	ExclusiveMinimum     bool             `json:"exclusiveMinimum,omitempty"`
-	MaxLength            *int64           `json:"maxLength,omitempty"`
-	MinLength            *int64           `json:"minLength,omitempty"`
-	Pattern              string           `json:"pattern,omitempty"`
-	MaxItems             *int64           `json:"maxItems,omitempty"`
-	MinItems             *int64           `json:"minItems,omitempty"`
-	UniqueItems          bool             `json:"uniqueItems,omitempty"`
-	MultipleOf           *float64         `json:"multipleOf,omitempty"`
-	Enum                 []interface{}    `json:"enum,omitempty"`
-	MaxProperties        *int64           `json:"maxProperties,omitempty"`
-	MinProperties        *int64           `json:"minProperties,omitempty"`
-	Required             []string         `json:"required,omitempty"`
-	Items                *SchemaOrArray   `json:"items,omitempty"`
-	AllOf                []Schema         `json:"allOf,omitempty"`
-	OneOf                []Schema         `json:"oneOf,omitempty"`
-	AnyOf                []Schema         `json:"anyOf,omitempty"`
-	Not                  *Schema          `json:"not,omitempty"`
-	Properties           SchemaProperties `json:"properties,omitempty"`
-	AdditionalProperties *SchemaOrBool    `json:"additionalProperties,omitempty"`
-	PatternProperties    SchemaProperties `json:"patternProperties,omitempty"`
-	Dependencies         Dependencies     `json:"dependencies,omitempty"`
-	AdditionalItems      *SchemaOrBool    `json:"additionalItems,omitempty"`
-	Definitions          Definitions      `json:"definitions,omitempty"`
-}
-
-// SwaggerSchemaProps are additional properties supported by swagger schemas, but not JSON-schema (draft 4)
-type SwaggerSchemaProps struct {
-	Discriminator string                 `json:"discriminator,omitempty"`
-	ReadOnly      bool                   `json:"readOnly,omitempty"`
-	XML           *XMLObject             `json:"xml,omitempty"`
-	ExternalDocs  *ExternalDocumentation `json:"externalDocs,omitempty"`
-	Example       interface{}            `json:"example,omitempty"`
-}
-
-// Schema the schema object allows the definition of input and output data types.
-// These types can be objects, but also primitives and arrays.
-// This object is based on the [JSON Schema Specification Draft 4](http://json-schema.org/)
-// and uses a predefined subset of it.
-// On top of this subset, there are extensions provided by this specification to allow for more complete documentation.
-//
-// For more information: http://goo.gl/8us55a#schemaObject
-type Schema struct {
-	VendorExtensible
-	SchemaProps
-	SwaggerSchemaProps
-	ExtraProps map[string]interface{} `json:"-"`
-}
-
-// JSONLookup implements an interface to customize json pointer lookup
-func (s Schema) JSONLookup(token string) (interface{}, error) {
-	if ex, ok := s.Extensions[token]; ok {
-		return &ex, nil
-	}
-
-	if ex, ok := s.ExtraProps[token]; ok {
-		return &ex, nil
-	}
-
-	r, _, err := jsonpointer.GetForToken(s.SchemaProps, token)
-	if r != nil || (err != nil && !strings.HasPrefix(err.Error(), "object has no field")) {
-		return r, err
-	}
-	r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token)
-	return r, err
-}
-
-// WithID sets the id for this schema, allows for chaining
-func (s *Schema) WithID(id string) *Schema {
-	s.ID = id
-	return s
-}
-
-// WithTitle sets the title for this schema, allows for chaining
-func (s *Schema) WithTitle(title string) *Schema {
-	s.Title = title
-	return s
-}
-
-// WithDescription sets the description for this schema, allows for chaining
-func (s *Schema) WithDescription(description string) *Schema {
-	s.Description = description
-	return s
-}
-
-// WithProperties sets the properties for this schema
-func (s *Schema) WithProperties(schemas map[string]Schema) *Schema {
-	s.Properties = schemas
-	return s
-}
-
-// SetProperty sets a property on this schema
-func (s *Schema) SetProperty(name string, schema Schema) *Schema {
-	if s.Properties == nil {
-		s.Properties = make(map[string]Schema)
-	}
-	s.Properties[name] = schema
-	return s
-}
-
-// WithAllOf sets the all of property
-func (s *Schema) WithAllOf(schemas ...Schema) *Schema {
-	s.AllOf = schemas
-	return s
-}
-
-// WithMaxProperties sets the max number of properties an object can have
-func (s *Schema) WithMaxProperties(max int64) *Schema {
-	s.MaxProperties = &max
-	return s
-}
-
-// WithMinProperties sets the min number of properties an object must have
-func (s *Schema) WithMinProperties(min int64) *Schema {
-	s.MinProperties = &min
-	return s
-}
-
-// Typed sets the type of this schema for a single value item
-func (s *Schema) Typed(tpe, format string) *Schema {
-	s.Type = []string{tpe}
-	s.Format = format
-	return s
-}
-
-// AddType adds a type with potential format to the types for this schema
-func (s *Schema) AddType(tpe, format string) *Schema {
-	s.Type = append(s.Type, tpe)
-	if format != "" {
-		s.Format = format
-	}
-	return s
-}
-
-// AsNullable flags this schema as nullable.
-func (s *Schema) AsNullable() *Schema {
-	s.Nullable = true
-	return s
-}
-
-// CollectionOf a fluent builder method for an array parameter
-func (s *Schema) CollectionOf(items Schema) *Schema {
-	s.Type = []string{jsonArray}
-	s.Items = &SchemaOrArray{Schema: &items}
-	return s
-}
-
-// WithDefault sets the default value on this parameter
-func (s *Schema) WithDefault(defaultValue interface{}) *Schema {
-	s.Default = defaultValue
-	return s
-}
-
-// WithRequired flags this parameter as required
-func (s *Schema) WithRequired(items ...string) *Schema {
-	s.Required = items
-	return s
-}
-
-// AddRequired  adds field names to the required properties array
-func (s *Schema) AddRequired(items ...string) *Schema {
-	s.Required = append(s.Required, items...)
-	return s
-}
-
-// WithMaxLength sets a max length value
-func (s *Schema) WithMaxLength(max int64) *Schema {
-	s.MaxLength = &max
-	return s
-}
-
-// WithMinLength sets a min length value
-func (s *Schema) WithMinLength(min int64) *Schema {
-	s.MinLength = &min
-	return s
-}
-
-// WithPattern sets a pattern value
-func (s *Schema) WithPattern(pattern string) *Schema {
-	s.Pattern = pattern
-	return s
-}
-
-// WithMultipleOf sets a multiple of value
-func (s *Schema) WithMultipleOf(number float64) *Schema {
-	s.MultipleOf = &number
-	return s
-}
-
-// WithMaximum sets a maximum number value
-func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema {
-	s.Maximum = &max
-	s.ExclusiveMaximum = exclusive
-	return s
-}
-
-// WithMinimum sets a minimum number value
-func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema {
-	s.Minimum = &min
-	s.ExclusiveMinimum = exclusive
-	return s
-}
-
-// WithEnum sets a the enum values (replace)
-func (s *Schema) WithEnum(values ...interface{}) *Schema {
-	s.Enum = append([]interface{}{}, values...)
-	return s
-}
-
-// WithMaxItems sets the max items
-func (s *Schema) WithMaxItems(size int64) *Schema {
-	s.MaxItems = &size
-	return s
-}
-
-// WithMinItems sets the min items
-func (s *Schema) WithMinItems(size int64) *Schema {
-	s.MinItems = &size
-	return s
-}
-
-// UniqueValues dictates that this array can only have unique items
-func (s *Schema) UniqueValues() *Schema {
-	s.UniqueItems = true
-	return s
-}
-
-// AllowDuplicates this array can have duplicates
-func (s *Schema) AllowDuplicates() *Schema {
-	s.UniqueItems = false
-	return s
-}
-
-// AddToAllOf adds a schema to the allOf property
-func (s *Schema) AddToAllOf(schemas ...Schema) *Schema {
-	s.AllOf = append(s.AllOf, schemas...)
-	return s
-}
-
-// WithDiscriminator sets the name of the discriminator field
-func (s *Schema) WithDiscriminator(discriminator string) *Schema {
-	s.Discriminator = discriminator
-	return s
-}
-
-// AsReadOnly flags this schema as readonly
-func (s *Schema) AsReadOnly() *Schema {
-	s.ReadOnly = true
-	return s
-}
-
-// AsWritable flags this schema as writeable (not read-only)
-func (s *Schema) AsWritable() *Schema {
-	s.ReadOnly = false
-	return s
-}
-
-// WithExample sets the example for this schema
-func (s *Schema) WithExample(example interface{}) *Schema {
-	s.Example = example
-	return s
-}
-
-// WithExternalDocs sets/removes the external docs for/from this schema.
-// When you pass empty strings as params the external documents will be removed.
-// When you pass non-empty string as one value then those values will be used on the external docs object.
-// So when you pass a non-empty description, you should also pass the url and vice versa.
-func (s *Schema) WithExternalDocs(description, url string) *Schema {
-	if description == "" && url == "" {
-		s.ExternalDocs = nil
-		return s
-	}
-
-	if s.ExternalDocs == nil {
-		s.ExternalDocs = &ExternalDocumentation{}
-	}
-	s.ExternalDocs.Description = description
-	s.ExternalDocs.URL = url
-	return s
-}
-
-// WithXMLName sets the xml name for the object
-func (s *Schema) WithXMLName(name string) *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Name = name
-	return s
-}
-
-// WithXMLNamespace sets the xml namespace for the object
-func (s *Schema) WithXMLNamespace(namespace string) *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Namespace = namespace
-	return s
-}
-
-// WithXMLPrefix sets the xml prefix for the object
-func (s *Schema) WithXMLPrefix(prefix string) *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Prefix = prefix
-	return s
-}
-
-// AsXMLAttribute flags this object as xml attribute
-func (s *Schema) AsXMLAttribute() *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Attribute = true
-	return s
-}
-
-// AsXMLElement flags this object as an xml node
-func (s *Schema) AsXMLElement() *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Attribute = false
-	return s
-}
-
-// AsWrappedXML flags this object as wrapped, this is mostly useful for array types
-func (s *Schema) AsWrappedXML() *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Wrapped = true
-	return s
-}
-
-// AsUnwrappedXML flags this object as an xml node
-func (s *Schema) AsUnwrappedXML() *Schema {
-	if s.XML == nil {
-		s.XML = new(XMLObject)
-	}
-	s.XML.Wrapped = false
-	return s
-}
-
-// SetValidations defines all schema validations.
-//
-// NOTE: Required, ReadOnly, AllOf, AnyOf, OneOf and Not are not considered.
-func (s *Schema) SetValidations(val SchemaValidations) {
-	s.Maximum = val.Maximum
-	s.ExclusiveMaximum = val.ExclusiveMaximum
-	s.Minimum = val.Minimum
-	s.ExclusiveMinimum = val.ExclusiveMinimum
-	s.MaxLength = val.MaxLength
-	s.MinLength = val.MinLength
-	s.Pattern = val.Pattern
-	s.MaxItems = val.MaxItems
-	s.MinItems = val.MinItems
-	s.UniqueItems = val.UniqueItems
-	s.MultipleOf = val.MultipleOf
-	s.Enum = val.Enum
-	s.MinProperties = val.MinProperties
-	s.MaxProperties = val.MaxProperties
-	s.PatternProperties = val.PatternProperties
-}
-
-// WithValidations is a fluent method to set schema validations
-func (s *Schema) WithValidations(val SchemaValidations) *Schema {
-	s.SetValidations(val)
-	return s
-}
-
-// Validations returns a clone of the validations for this schema
-func (s Schema) Validations() SchemaValidations {
-	return SchemaValidations{
-		CommonValidations: CommonValidations{
-			Maximum:          s.Maximum,
-			ExclusiveMaximum: s.ExclusiveMaximum,
-			Minimum:          s.Minimum,
-			ExclusiveMinimum: s.ExclusiveMinimum,
-			MaxLength:        s.MaxLength,
-			MinLength:        s.MinLength,
-			Pattern:          s.Pattern,
-			MaxItems:         s.MaxItems,
-			MinItems:         s.MinItems,
-			UniqueItems:      s.UniqueItems,
-			MultipleOf:       s.MultipleOf,
-			Enum:             s.Enum,
-		},
-		MinProperties:     s.MinProperties,
-		MaxProperties:     s.MaxProperties,
-		PatternProperties: s.PatternProperties,
-	}
-}
-
-// MarshalJSON marshal this to JSON
-func (s Schema) MarshalJSON() ([]byte, error) {
-	b1, err := json.Marshal(s.SchemaProps)
-	if err != nil {
-		return nil, fmt.Errorf("schema props %v", err)
-	}
-	b2, err := json.Marshal(s.VendorExtensible)
-	if err != nil {
-		return nil, fmt.Errorf("vendor props %v", err)
-	}
-	b3, err := s.Ref.MarshalJSON()
-	if err != nil {
-		return nil, fmt.Errorf("ref prop %v", err)
-	}
-	b4, err := s.Schema.MarshalJSON()
-	if err != nil {
-		return nil, fmt.Errorf("schema prop %v", err)
-	}
-	b5, err := json.Marshal(s.SwaggerSchemaProps)
-	if err != nil {
-		return nil, fmt.Errorf("common validations %v", err)
-	}
-	var b6 []byte
-	if s.ExtraProps != nil {
-		jj, err := json.Marshal(s.ExtraProps)
-		if err != nil {
-			return nil, fmt.Errorf("extra props %v", err)
-		}
-		b6 = jj
-	}
-	return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil
-}
-
-// UnmarshalJSON marshal this from JSON
-func (s *Schema) UnmarshalJSON(data []byte) error {
-	props := struct {
-		SchemaProps
-		SwaggerSchemaProps
-	}{}
-	if err := json.Unmarshal(data, &props); err != nil {
-		return err
-	}
-
-	sch := Schema{
-		SchemaProps:        props.SchemaProps,
-		SwaggerSchemaProps: props.SwaggerSchemaProps,
-	}
-
-	var d map[string]interface{}
-	if err := json.Unmarshal(data, &d); err != nil {
-		return err
-	}
-
-	_ = sch.Ref.fromMap(d)
-	_ = sch.Schema.fromMap(d)
-
-	delete(d, "$ref")
-	delete(d, "$schema")
-	for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) {
-		delete(d, pn)
-	}
-
-	for k, vv := range d {
-		lk := strings.ToLower(k)
-		if strings.HasPrefix(lk, "x-") {
-			if sch.Extensions == nil {
-				sch.Extensions = map[string]interface{}{}
-			}
-			sch.Extensions[k] = vv
-			continue
-		}
-		if sch.ExtraProps == nil {
-			sch.ExtraProps = map[string]interface{}{}
-		}
-		sch.ExtraProps[k] = vv
-	}
-
-	*s = sch
-
-	return nil
-}