▽

Source file src/github.com/google/gnostic-models/openapiv2/OpenAPIv2.go

Documentation: github.com/google/gnostic-models/openapiv2

     1  // Copyright 2020 Google LLC. All Rights Reserved.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // THIS FILE IS AUTOMATICALLY GENERATED.
    16  
    17  package openapi_v2
    18  
    19  import (
    20  	"fmt"
    21  	"regexp"
    22  	"strings"
    23  
    24  	"gopkg.in/yaml.v3"
    25  
    26  	"github.com/google/gnostic-models/compiler"
    27  )
    28  
    29  // Version returns the package name (and OpenAPI version).
    30  func Version() string {
    31  	return "openapi_v2"
    32  }
    33  
    34  // NewAdditionalPropertiesItem creates an object of type AdditionalPropertiesItem if possible, returning an error if not.
    35  func NewAdditionalPropertiesItem(in *yaml.Node, context *compiler.Context) (*AdditionalPropertiesItem, error) {
    36  	errors := make([]error, 0)
    37  	x := &AdditionalPropertiesItem{}
    38  	matched := false
    39  	// Schema schema = 1;
    40  	{
    41  		m, ok := compiler.UnpackMap(in)
    42  		if ok {
    43  			// errors might be ok here, they mean we just don't have the right subtype
    44  			t, matchingError := NewSchema(m, compiler.NewContext("schema", m, context))
    45  			if matchingError == nil {
    46  				x.Oneof = &AdditionalPropertiesItem_Schema{Schema: t}
    47  				matched = true
    48  			} else {
    49  				errors = append(errors, matchingError)
    50  			}
    51  		}
    52  	}
    53  	// bool boolean = 2;
    54  	boolValue, ok := compiler.BoolForScalarNode(in)
    55  	if ok {
    56  		x.Oneof = &AdditionalPropertiesItem_Boolean{Boolean: boolValue}
    57  		matched = true
    58  	}
    59  	if matched {
    60  		// since the oneof matched one of its possibilities, discard any matching errors
    61  		errors = make([]error, 0)
    62  	} else {
    63  		message := fmt.Sprintf("contains an invalid AdditionalPropertiesItem")
    64  		err := compiler.NewError(context, message)
    65  		errors = []error{err}
    66  	}
    67  	return x, compiler.NewErrorGroupOrNil(errors)
    68  }
    69  
    70  // NewAny creates an object of type Any if possible, returning an error if not.
    71  func NewAny(in *yaml.Node, context *compiler.Context) (*Any, error) {
    72  	errors := make([]error, 0)
    73  	x := &Any{}
    74  	bytes := compiler.Marshal(in)
    75  	x.Yaml = string(bytes)
    76  	return x, compiler.NewErrorGroupOrNil(errors)
    77  }
    78  
    79  // NewApiKeySecurity creates an object of type ApiKeySecurity if possible, returning an error if not.
    80  func NewApiKeySecurity(in *yaml.Node, context *compiler.Context) (*ApiKeySecurity, error) {
    81  	errors := make([]error, 0)
    82  	x := &ApiKeySecurity{}
    83  	m, ok := compiler.UnpackMap(in)
    84  	if !ok {
    85  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
    86  		errors = append(errors, compiler.NewError(context, message))
    87  	} else {
    88  		requiredKeys := []string{"in", "name", "type"}
    89  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
    90  		if len(missingKeys) > 0 {
    91  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
    92  			errors = append(errors, compiler.NewError(context, message))
    93  		}
    94  		allowedKeys := []string{"description", "in", "name", "type"}
    95  		allowedPatterns := []*regexp.Regexp{pattern0}
    96  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
    97  		if len(invalidKeys) > 0 {
    98  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
    99  			errors = append(errors, compiler.NewError(context, message))
   100  		}
   101  		// string type = 1;
   102  		v1 := compiler.MapValueForKey(m, "type")
   103  		if v1 != nil {
   104  			x.Type, ok = compiler.StringForScalarNode(v1)
   105  			if !ok {
   106  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
   107  				errors = append(errors, compiler.NewError(context, message))
   108  			}
   109  			// check for valid enum values
   110  			// [apiKey]
   111  			if ok && !compiler.StringArrayContainsValue([]string{"apiKey"}, x.Type) {
   112  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
   113  				errors = append(errors, compiler.NewError(context, message))
   114  			}
   115  		}
   116  		// string name = 2;
   117  		v2 := compiler.MapValueForKey(m, "name")
   118  		if v2 != nil {
   119  			x.Name, ok = compiler.StringForScalarNode(v2)
   120  			if !ok {
   121  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v2))
   122  				errors = append(errors, compiler.NewError(context, message))
   123  			}
   124  		}
   125  		// string in = 3;
   126  		v3 := compiler.MapValueForKey(m, "in")
   127  		if v3 != nil {
   128  			x.In, ok = compiler.StringForScalarNode(v3)
   129  			if !ok {
   130  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v3))
   131  				errors = append(errors, compiler.NewError(context, message))
   132  			}
   133  			// check for valid enum values
   134  			// [header query]
   135  			if ok && !compiler.StringArrayContainsValue([]string{"header", "query"}, x.In) {
   136  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v3))
   137  				errors = append(errors, compiler.NewError(context, message))
   138  			}
   139  		}
   140  		// string description = 4;
   141  		v4 := compiler.MapValueForKey(m, "description")
   142  		if v4 != nil {
   143  			x.Description, ok = compiler.StringForScalarNode(v4)
   144  			if !ok {
   145  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v4))
   146  				errors = append(errors, compiler.NewError(context, message))
   147  			}
   148  		}
   149  		// repeated NamedAny vendor_extension = 5;
   150  		// MAP: Any ^x-
   151  		x.VendorExtension = make([]*NamedAny, 0)
   152  		for i := 0; i < len(m.Content); i += 2 {
   153  			k, ok := compiler.StringForScalarNode(m.Content[i])
   154  			if ok {
   155  				v := m.Content[i+1]
   156  				if strings.HasPrefix(k, "x-") {
   157  					pair := &NamedAny{}
   158  					pair.Name = k
   159  					result := &Any{}
   160  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   161  					if handled {
   162  						if err != nil {
   163  							errors = append(errors, err)
   164  						} else {
   165  							bytes := compiler.Marshal(v)
   166  							result.Yaml = string(bytes)
   167  							result.Value = resultFromExt
   168  							pair.Value = result
   169  						}
   170  					} else {
   171  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   172  						if err != nil {
   173  							errors = append(errors, err)
   174  						}
   175  					}
   176  					x.VendorExtension = append(x.VendorExtension, pair)
   177  				}
   178  			}
   179  		}
   180  	}
   181  	return x, compiler.NewErrorGroupOrNil(errors)
   182  }
   183  
   184  // NewBasicAuthenticationSecurity creates an object of type BasicAuthenticationSecurity if possible, returning an error if not.
   185  func NewBasicAuthenticationSecurity(in *yaml.Node, context *compiler.Context) (*BasicAuthenticationSecurity, error) {
   186  	errors := make([]error, 0)
   187  	x := &BasicAuthenticationSecurity{}
   188  	m, ok := compiler.UnpackMap(in)
   189  	if !ok {
   190  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   191  		errors = append(errors, compiler.NewError(context, message))
   192  	} else {
   193  		requiredKeys := []string{"type"}
   194  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
   195  		if len(missingKeys) > 0 {
   196  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
   197  			errors = append(errors, compiler.NewError(context, message))
   198  		}
   199  		allowedKeys := []string{"description", "type"}
   200  		allowedPatterns := []*regexp.Regexp{pattern0}
   201  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   202  		if len(invalidKeys) > 0 {
   203  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   204  			errors = append(errors, compiler.NewError(context, message))
   205  		}
   206  		// string type = 1;
   207  		v1 := compiler.MapValueForKey(m, "type")
   208  		if v1 != nil {
   209  			x.Type, ok = compiler.StringForScalarNode(v1)
   210  			if !ok {
   211  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
   212  				errors = append(errors, compiler.NewError(context, message))
   213  			}
   214  			// check for valid enum values
   215  			// [basic]
   216  			if ok && !compiler.StringArrayContainsValue([]string{"basic"}, x.Type) {
   217  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
   218  				errors = append(errors, compiler.NewError(context, message))
   219  			}
   220  		}
   221  		// string description = 2;
   222  		v2 := compiler.MapValueForKey(m, "description")
   223  		if v2 != nil {
   224  			x.Description, ok = compiler.StringForScalarNode(v2)
   225  			if !ok {
   226  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
   227  				errors = append(errors, compiler.NewError(context, message))
   228  			}
   229  		}
   230  		// repeated NamedAny vendor_extension = 3;
   231  		// MAP: Any ^x-
   232  		x.VendorExtension = make([]*NamedAny, 0)
   233  		for i := 0; i < len(m.Content); i += 2 {
   234  			k, ok := compiler.StringForScalarNode(m.Content[i])
   235  			if ok {
   236  				v := m.Content[i+1]
   237  				if strings.HasPrefix(k, "x-") {
   238  					pair := &NamedAny{}
   239  					pair.Name = k
   240  					result := &Any{}
   241  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   242  					if handled {
   243  						if err != nil {
   244  							errors = append(errors, err)
   245  						} else {
   246  							bytes := compiler.Marshal(v)
   247  							result.Yaml = string(bytes)
   248  							result.Value = resultFromExt
   249  							pair.Value = result
   250  						}
   251  					} else {
   252  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   253  						if err != nil {
   254  							errors = append(errors, err)
   255  						}
   256  					}
   257  					x.VendorExtension = append(x.VendorExtension, pair)
   258  				}
   259  			}
   260  		}
   261  	}
   262  	return x, compiler.NewErrorGroupOrNil(errors)
   263  }
   264  
   265  // NewBodyParameter creates an object of type BodyParameter if possible, returning an error if not.
   266  func NewBodyParameter(in *yaml.Node, context *compiler.Context) (*BodyParameter, error) {
   267  	errors := make([]error, 0)
   268  	x := &BodyParameter{}
   269  	m, ok := compiler.UnpackMap(in)
   270  	if !ok {
   271  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   272  		errors = append(errors, compiler.NewError(context, message))
   273  	} else {
   274  		requiredKeys := []string{"in", "name", "schema"}
   275  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
   276  		if len(missingKeys) > 0 {
   277  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
   278  			errors = append(errors, compiler.NewError(context, message))
   279  		}
   280  		allowedKeys := []string{"description", "in", "name", "required", "schema"}
   281  		allowedPatterns := []*regexp.Regexp{pattern0}
   282  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   283  		if len(invalidKeys) > 0 {
   284  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   285  			errors = append(errors, compiler.NewError(context, message))
   286  		}
   287  		// string description = 1;
   288  		v1 := compiler.MapValueForKey(m, "description")
   289  		if v1 != nil {
   290  			x.Description, ok = compiler.StringForScalarNode(v1)
   291  			if !ok {
   292  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v1))
   293  				errors = append(errors, compiler.NewError(context, message))
   294  			}
   295  		}
   296  		// string name = 2;
   297  		v2 := compiler.MapValueForKey(m, "name")
   298  		if v2 != nil {
   299  			x.Name, ok = compiler.StringForScalarNode(v2)
   300  			if !ok {
   301  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v2))
   302  				errors = append(errors, compiler.NewError(context, message))
   303  			}
   304  		}
   305  		// string in = 3;
   306  		v3 := compiler.MapValueForKey(m, "in")
   307  		if v3 != nil {
   308  			x.In, ok = compiler.StringForScalarNode(v3)
   309  			if !ok {
   310  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v3))
   311  				errors = append(errors, compiler.NewError(context, message))
   312  			}
   313  			// check for valid enum values
   314  			// [body]
   315  			if ok && !compiler.StringArrayContainsValue([]string{"body"}, x.In) {
   316  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v3))
   317  				errors = append(errors, compiler.NewError(context, message))
   318  			}
   319  		}
   320  		// bool required = 4;
   321  		v4 := compiler.MapValueForKey(m, "required")
   322  		if v4 != nil {
   323  			x.Required, ok = compiler.BoolForScalarNode(v4)
   324  			if !ok {
   325  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v4))
   326  				errors = append(errors, compiler.NewError(context, message))
   327  			}
   328  		}
   329  		// Schema schema = 5;
   330  		v5 := compiler.MapValueForKey(m, "schema")
   331  		if v5 != nil {
   332  			var err error
   333  			x.Schema, err = NewSchema(v5, compiler.NewContext("schema", v5, context))
   334  			if err != nil {
   335  				errors = append(errors, err)
   336  			}
   337  		}
   338  		// repeated NamedAny vendor_extension = 6;
   339  		// MAP: Any ^x-
   340  		x.VendorExtension = make([]*NamedAny, 0)
   341  		for i := 0; i < len(m.Content); i += 2 {
   342  			k, ok := compiler.StringForScalarNode(m.Content[i])
   343  			if ok {
   344  				v := m.Content[i+1]
   345  				if strings.HasPrefix(k, "x-") {
   346  					pair := &NamedAny{}
   347  					pair.Name = k
   348  					result := &Any{}
   349  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   350  					if handled {
   351  						if err != nil {
   352  							errors = append(errors, err)
   353  						} else {
   354  							bytes := compiler.Marshal(v)
   355  							result.Yaml = string(bytes)
   356  							result.Value = resultFromExt
   357  							pair.Value = result
   358  						}
   359  					} else {
   360  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   361  						if err != nil {
   362  							errors = append(errors, err)
   363  						}
   364  					}
   365  					x.VendorExtension = append(x.VendorExtension, pair)
   366  				}
   367  			}
   368  		}
   369  	}
   370  	return x, compiler.NewErrorGroupOrNil(errors)
   371  }
   372  
   373  // NewContact creates an object of type Contact if possible, returning an error if not.
   374  func NewContact(in *yaml.Node, context *compiler.Context) (*Contact, error) {
   375  	errors := make([]error, 0)
   376  	x := &Contact{}
   377  	m, ok := compiler.UnpackMap(in)
   378  	if !ok {
   379  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   380  		errors = append(errors, compiler.NewError(context, message))
   381  	} else {
   382  		allowedKeys := []string{"email", "name", "url"}
   383  		allowedPatterns := []*regexp.Regexp{pattern0}
   384  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   385  		if len(invalidKeys) > 0 {
   386  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   387  			errors = append(errors, compiler.NewError(context, message))
   388  		}
   389  		// string name = 1;
   390  		v1 := compiler.MapValueForKey(m, "name")
   391  		if v1 != nil {
   392  			x.Name, ok = compiler.StringForScalarNode(v1)
   393  			if !ok {
   394  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
   395  				errors = append(errors, compiler.NewError(context, message))
   396  			}
   397  		}
   398  		// string url = 2;
   399  		v2 := compiler.MapValueForKey(m, "url")
   400  		if v2 != nil {
   401  			x.Url, ok = compiler.StringForScalarNode(v2)
   402  			if !ok {
   403  				message := fmt.Sprintf("has unexpected value for url: %s", compiler.Display(v2))
   404  				errors = append(errors, compiler.NewError(context, message))
   405  			}
   406  		}
   407  		// string email = 3;
   408  		v3 := compiler.MapValueForKey(m, "email")
   409  		if v3 != nil {
   410  			x.Email, ok = compiler.StringForScalarNode(v3)
   411  			if !ok {
   412  				message := fmt.Sprintf("has unexpected value for email: %s", compiler.Display(v3))
   413  				errors = append(errors, compiler.NewError(context, message))
   414  			}
   415  		}
   416  		// repeated NamedAny vendor_extension = 4;
   417  		// MAP: Any ^x-
   418  		x.VendorExtension = make([]*NamedAny, 0)
   419  		for i := 0; i < len(m.Content); i += 2 {
   420  			k, ok := compiler.StringForScalarNode(m.Content[i])
   421  			if ok {
   422  				v := m.Content[i+1]
   423  				if strings.HasPrefix(k, "x-") {
   424  					pair := &NamedAny{}
   425  					pair.Name = k
   426  					result := &Any{}
   427  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   428  					if handled {
   429  						if err != nil {
   430  							errors = append(errors, err)
   431  						} else {
   432  							bytes := compiler.Marshal(v)
   433  							result.Yaml = string(bytes)
   434  							result.Value = resultFromExt
   435  							pair.Value = result
   436  						}
   437  					} else {
   438  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   439  						if err != nil {
   440  							errors = append(errors, err)
   441  						}
   442  					}
   443  					x.VendorExtension = append(x.VendorExtension, pair)
   444  				}
   445  			}
   446  		}
   447  	}
   448  	return x, compiler.NewErrorGroupOrNil(errors)
   449  }
   450  
   451  // NewDefault creates an object of type Default if possible, returning an error if not.
   452  func NewDefault(in *yaml.Node, context *compiler.Context) (*Default, error) {
   453  	errors := make([]error, 0)
   454  	x := &Default{}
   455  	m, ok := compiler.UnpackMap(in)
   456  	if !ok {
   457  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   458  		errors = append(errors, compiler.NewError(context, message))
   459  	} else {
   460  		// repeated NamedAny additional_properties = 1;
   461  		// MAP: Any
   462  		x.AdditionalProperties = make([]*NamedAny, 0)
   463  		for i := 0; i < len(m.Content); i += 2 {
   464  			k, ok := compiler.StringForScalarNode(m.Content[i])
   465  			if ok {
   466  				v := m.Content[i+1]
   467  				pair := &NamedAny{}
   468  				pair.Name = k
   469  				result := &Any{}
   470  				handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   471  				if handled {
   472  					if err != nil {
   473  						errors = append(errors, err)
   474  					} else {
   475  						bytes := compiler.Marshal(v)
   476  						result.Yaml = string(bytes)
   477  						result.Value = resultFromExt
   478  						pair.Value = result
   479  					}
   480  				} else {
   481  					pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   482  					if err != nil {
   483  						errors = append(errors, err)
   484  					}
   485  				}
   486  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
   487  			}
   488  		}
   489  	}
   490  	return x, compiler.NewErrorGroupOrNil(errors)
   491  }
   492  
   493  // NewDefinitions creates an object of type Definitions if possible, returning an error if not.
   494  func NewDefinitions(in *yaml.Node, context *compiler.Context) (*Definitions, error) {
   495  	errors := make([]error, 0)
   496  	x := &Definitions{}
   497  	m, ok := compiler.UnpackMap(in)
   498  	if !ok {
   499  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   500  		errors = append(errors, compiler.NewError(context, message))
   501  	} else {
   502  		// repeated NamedSchema additional_properties = 1;
   503  		// MAP: Schema
   504  		x.AdditionalProperties = make([]*NamedSchema, 0)
   505  		for i := 0; i < len(m.Content); i += 2 {
   506  			k, ok := compiler.StringForScalarNode(m.Content[i])
   507  			if ok {
   508  				v := m.Content[i+1]
   509  				pair := &NamedSchema{}
   510  				pair.Name = k
   511  				var err error
   512  				pair.Value, err = NewSchema(v, compiler.NewContext(k, v, context))
   513  				if err != nil {
   514  					errors = append(errors, err)
   515  				}
   516  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
   517  			}
   518  		}
   519  	}
   520  	return x, compiler.NewErrorGroupOrNil(errors)
   521  }
   522  
   523  // NewDocument creates an object of type Document if possible, returning an error if not.
   524  func NewDocument(in *yaml.Node, context *compiler.Context) (*Document, error) {
   525  	errors := make([]error, 0)
   526  	x := &Document{}
   527  	m, ok := compiler.UnpackMap(in)
   528  	if !ok {
   529  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   530  		errors = append(errors, compiler.NewError(context, message))
   531  	} else {
   532  		requiredKeys := []string{"info", "paths", "swagger"}
   533  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
   534  		if len(missingKeys) > 0 {
   535  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
   536  			errors = append(errors, compiler.NewError(context, message))
   537  		}
   538  		allowedKeys := []string{"basePath", "consumes", "definitions", "externalDocs", "host", "info", "parameters", "paths", "produces", "responses", "schemes", "security", "securityDefinitions", "swagger", "tags"}
   539  		allowedPatterns := []*regexp.Regexp{pattern0}
   540  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   541  		if len(invalidKeys) > 0 {
   542  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   543  			errors = append(errors, compiler.NewError(context, message))
   544  		}
   545  		// string swagger = 1;
   546  		v1 := compiler.MapValueForKey(m, "swagger")
   547  		if v1 != nil {
   548  			x.Swagger, ok = compiler.StringForScalarNode(v1)
   549  			if !ok {
   550  				message := fmt.Sprintf("has unexpected value for swagger: %s", compiler.Display(v1))
   551  				errors = append(errors, compiler.NewError(context, message))
   552  			}
   553  			// check for valid enum values
   554  			// [2.0]
   555  			if ok && !compiler.StringArrayContainsValue([]string{"2.0"}, x.Swagger) {
   556  				message := fmt.Sprintf("has unexpected value for swagger: %s", compiler.Display(v1))
   557  				errors = append(errors, compiler.NewError(context, message))
   558  			}
   559  		}
   560  		// Info info = 2;
   561  		v2 := compiler.MapValueForKey(m, "info")
   562  		if v2 != nil {
   563  			var err error
   564  			x.Info, err = NewInfo(v2, compiler.NewContext("info", v2, context))
   565  			if err != nil {
   566  				errors = append(errors, err)
   567  			}
   568  		}
   569  		// string host = 3;
   570  		v3 := compiler.MapValueForKey(m, "host")
   571  		if v3 != nil {
   572  			x.Host, ok = compiler.StringForScalarNode(v3)
   573  			if !ok {
   574  				message := fmt.Sprintf("has unexpected value for host: %s", compiler.Display(v3))
   575  				errors = append(errors, compiler.NewError(context, message))
   576  			}
   577  		}
   578  		// string base_path = 4;
   579  		v4 := compiler.MapValueForKey(m, "basePath")
   580  		if v4 != nil {
   581  			x.BasePath, ok = compiler.StringForScalarNode(v4)
   582  			if !ok {
   583  				message := fmt.Sprintf("has unexpected value for basePath: %s", compiler.Display(v4))
   584  				errors = append(errors, compiler.NewError(context, message))
   585  			}
   586  		}
   587  		// repeated string schemes = 5;
   588  		v5 := compiler.MapValueForKey(m, "schemes")
   589  		if v5 != nil {
   590  			v, ok := compiler.SequenceNodeForNode(v5)
   591  			if ok {
   592  				x.Schemes = compiler.StringArrayForSequenceNode(v)
   593  			} else {
   594  				message := fmt.Sprintf("has unexpected value for schemes: %s", compiler.Display(v5))
   595  				errors = append(errors, compiler.NewError(context, message))
   596  			}
   597  			// check for valid enum values
   598  			// [http https ws wss]
   599  			if ok && !compiler.StringArrayContainsValues([]string{"http", "https", "ws", "wss"}, x.Schemes) {
   600  				message := fmt.Sprintf("has unexpected value for schemes: %s", compiler.Display(v5))
   601  				errors = append(errors, compiler.NewError(context, message))
   602  			}
   603  		}
   604  		// repeated string consumes = 6;
   605  		v6 := compiler.MapValueForKey(m, "consumes")
   606  		if v6 != nil {
   607  			v, ok := compiler.SequenceNodeForNode(v6)
   608  			if ok {
   609  				x.Consumes = compiler.StringArrayForSequenceNode(v)
   610  			} else {
   611  				message := fmt.Sprintf("has unexpected value for consumes: %s", compiler.Display(v6))
   612  				errors = append(errors, compiler.NewError(context, message))
   613  			}
   614  		}
   615  		// repeated string produces = 7;
   616  		v7 := compiler.MapValueForKey(m, "produces")
   617  		if v7 != nil {
   618  			v, ok := compiler.SequenceNodeForNode(v7)
   619  			if ok {
   620  				x.Produces = compiler.StringArrayForSequenceNode(v)
   621  			} else {
   622  				message := fmt.Sprintf("has unexpected value for produces: %s", compiler.Display(v7))
   623  				errors = append(errors, compiler.NewError(context, message))
   624  			}
   625  		}
   626  		// Paths paths = 8;
   627  		v8 := compiler.MapValueForKey(m, "paths")
   628  		if v8 != nil {
   629  			var err error
   630  			x.Paths, err = NewPaths(v8, compiler.NewContext("paths", v8, context))
   631  			if err != nil {
   632  				errors = append(errors, err)
   633  			}
   634  		}
   635  		// Definitions definitions = 9;
   636  		v9 := compiler.MapValueForKey(m, "definitions")
   637  		if v9 != nil {
   638  			var err error
   639  			x.Definitions, err = NewDefinitions(v9, compiler.NewContext("definitions", v9, context))
   640  			if err != nil {
   641  				errors = append(errors, err)
   642  			}
   643  		}
   644  		// ParameterDefinitions parameters = 10;
   645  		v10 := compiler.MapValueForKey(m, "parameters")
   646  		if v10 != nil {
   647  			var err error
   648  			x.Parameters, err = NewParameterDefinitions(v10, compiler.NewContext("parameters", v10, context))
   649  			if err != nil {
   650  				errors = append(errors, err)
   651  			}
   652  		}
   653  		// ResponseDefinitions responses = 11;
   654  		v11 := compiler.MapValueForKey(m, "responses")
   655  		if v11 != nil {
   656  			var err error
   657  			x.Responses, err = NewResponseDefinitions(v11, compiler.NewContext("responses", v11, context))
   658  			if err != nil {
   659  				errors = append(errors, err)
   660  			}
   661  		}
   662  		// repeated SecurityRequirement security = 12;
   663  		v12 := compiler.MapValueForKey(m, "security")
   664  		if v12 != nil {
   665  			// repeated SecurityRequirement
   666  			x.Security = make([]*SecurityRequirement, 0)
   667  			a, ok := compiler.SequenceNodeForNode(v12)
   668  			if ok {
   669  				for _, item := range a.Content {
   670  					y, err := NewSecurityRequirement(item, compiler.NewContext("security", item, context))
   671  					if err != nil {
   672  						errors = append(errors, err)
   673  					}
   674  					x.Security = append(x.Security, y)
   675  				}
   676  			}
   677  		}
   678  		// SecurityDefinitions security_definitions = 13;
   679  		v13 := compiler.MapValueForKey(m, "securityDefinitions")
   680  		if v13 != nil {
   681  			var err error
   682  			x.SecurityDefinitions, err = NewSecurityDefinitions(v13, compiler.NewContext("securityDefinitions", v13, context))
   683  			if err != nil {
   684  				errors = append(errors, err)
   685  			}
   686  		}
   687  		// repeated Tag tags = 14;
   688  		v14 := compiler.MapValueForKey(m, "tags")
   689  		if v14 != nil {
   690  			// repeated Tag
   691  			x.Tags = make([]*Tag, 0)
   692  			a, ok := compiler.SequenceNodeForNode(v14)
   693  			if ok {
   694  				for _, item := range a.Content {
   695  					y, err := NewTag(item, compiler.NewContext("tags", item, context))
   696  					if err != nil {
   697  						errors = append(errors, err)
   698  					}
   699  					x.Tags = append(x.Tags, y)
   700  				}
   701  			}
   702  		}
   703  		// ExternalDocs external_docs = 15;
   704  		v15 := compiler.MapValueForKey(m, "externalDocs")
   705  		if v15 != nil {
   706  			var err error
   707  			x.ExternalDocs, err = NewExternalDocs(v15, compiler.NewContext("externalDocs", v15, context))
   708  			if err != nil {
   709  				errors = append(errors, err)
   710  			}
   711  		}
   712  		// repeated NamedAny vendor_extension = 16;
   713  		// MAP: Any ^x-
   714  		x.VendorExtension = make([]*NamedAny, 0)
   715  		for i := 0; i < len(m.Content); i += 2 {
   716  			k, ok := compiler.StringForScalarNode(m.Content[i])
   717  			if ok {
   718  				v := m.Content[i+1]
   719  				if strings.HasPrefix(k, "x-") {
   720  					pair := &NamedAny{}
   721  					pair.Name = k
   722  					result := &Any{}
   723  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   724  					if handled {
   725  						if err != nil {
   726  							errors = append(errors, err)
   727  						} else {
   728  							bytes := compiler.Marshal(v)
   729  							result.Yaml = string(bytes)
   730  							result.Value = resultFromExt
   731  							pair.Value = result
   732  						}
   733  					} else {
   734  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   735  						if err != nil {
   736  							errors = append(errors, err)
   737  						}
   738  					}
   739  					x.VendorExtension = append(x.VendorExtension, pair)
   740  				}
   741  			}
   742  		}
   743  	}
   744  	return x, compiler.NewErrorGroupOrNil(errors)
   745  }
   746  
   747  // NewExamples creates an object of type Examples if possible, returning an error if not.
   748  func NewExamples(in *yaml.Node, context *compiler.Context) (*Examples, error) {
   749  	errors := make([]error, 0)
   750  	x := &Examples{}
   751  	m, ok := compiler.UnpackMap(in)
   752  	if !ok {
   753  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   754  		errors = append(errors, compiler.NewError(context, message))
   755  	} else {
   756  		// repeated NamedAny additional_properties = 1;
   757  		// MAP: Any
   758  		x.AdditionalProperties = make([]*NamedAny, 0)
   759  		for i := 0; i < len(m.Content); i += 2 {
   760  			k, ok := compiler.StringForScalarNode(m.Content[i])
   761  			if ok {
   762  				v := m.Content[i+1]
   763  				pair := &NamedAny{}
   764  				pair.Name = k
   765  				result := &Any{}
   766  				handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   767  				if handled {
   768  					if err != nil {
   769  						errors = append(errors, err)
   770  					} else {
   771  						bytes := compiler.Marshal(v)
   772  						result.Yaml = string(bytes)
   773  						result.Value = resultFromExt
   774  						pair.Value = result
   775  					}
   776  				} else {
   777  					pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   778  					if err != nil {
   779  						errors = append(errors, err)
   780  					}
   781  				}
   782  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
   783  			}
   784  		}
   785  	}
   786  	return x, compiler.NewErrorGroupOrNil(errors)
   787  }
   788  
   789  // NewExternalDocs creates an object of type ExternalDocs if possible, returning an error if not.
   790  func NewExternalDocs(in *yaml.Node, context *compiler.Context) (*ExternalDocs, error) {
   791  	errors := make([]error, 0)
   792  	x := &ExternalDocs{}
   793  	m, ok := compiler.UnpackMap(in)
   794  	if !ok {
   795  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   796  		errors = append(errors, compiler.NewError(context, message))
   797  	} else {
   798  		requiredKeys := []string{"url"}
   799  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
   800  		if len(missingKeys) > 0 {
   801  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
   802  			errors = append(errors, compiler.NewError(context, message))
   803  		}
   804  		allowedKeys := []string{"description", "url"}
   805  		allowedPatterns := []*regexp.Regexp{pattern0}
   806  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   807  		if len(invalidKeys) > 0 {
   808  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   809  			errors = append(errors, compiler.NewError(context, message))
   810  		}
   811  		// string description = 1;
   812  		v1 := compiler.MapValueForKey(m, "description")
   813  		if v1 != nil {
   814  			x.Description, ok = compiler.StringForScalarNode(v1)
   815  			if !ok {
   816  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v1))
   817  				errors = append(errors, compiler.NewError(context, message))
   818  			}
   819  		}
   820  		// string url = 2;
   821  		v2 := compiler.MapValueForKey(m, "url")
   822  		if v2 != nil {
   823  			x.Url, ok = compiler.StringForScalarNode(v2)
   824  			if !ok {
   825  				message := fmt.Sprintf("has unexpected value for url: %s", compiler.Display(v2))
   826  				errors = append(errors, compiler.NewError(context, message))
   827  			}
   828  		}
   829  		// repeated NamedAny vendor_extension = 3;
   830  		// MAP: Any ^x-
   831  		x.VendorExtension = make([]*NamedAny, 0)
   832  		for i := 0; i < len(m.Content); i += 2 {
   833  			k, ok := compiler.StringForScalarNode(m.Content[i])
   834  			if ok {
   835  				v := m.Content[i+1]
   836  				if strings.HasPrefix(k, "x-") {
   837  					pair := &NamedAny{}
   838  					pair.Name = k
   839  					result := &Any{}
   840  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   841  					if handled {
   842  						if err != nil {
   843  							errors = append(errors, err)
   844  						} else {
   845  							bytes := compiler.Marshal(v)
   846  							result.Yaml = string(bytes)
   847  							result.Value = resultFromExt
   848  							pair.Value = result
   849  						}
   850  					} else {
   851  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   852  						if err != nil {
   853  							errors = append(errors, err)
   854  						}
   855  					}
   856  					x.VendorExtension = append(x.VendorExtension, pair)
   857  				}
   858  			}
   859  		}
   860  	}
   861  	return x, compiler.NewErrorGroupOrNil(errors)
   862  }
   863  
   864  // NewFileSchema creates an object of type FileSchema if possible, returning an error if not.
   865  func NewFileSchema(in *yaml.Node, context *compiler.Context) (*FileSchema, error) {
   866  	errors := make([]error, 0)
   867  	x := &FileSchema{}
   868  	m, ok := compiler.UnpackMap(in)
   869  	if !ok {
   870  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
   871  		errors = append(errors, compiler.NewError(context, message))
   872  	} else {
   873  		requiredKeys := []string{"type"}
   874  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
   875  		if len(missingKeys) > 0 {
   876  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
   877  			errors = append(errors, compiler.NewError(context, message))
   878  		}
   879  		allowedKeys := []string{"default", "description", "example", "externalDocs", "format", "readOnly", "required", "title", "type"}
   880  		allowedPatterns := []*regexp.Regexp{pattern0}
   881  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
   882  		if len(invalidKeys) > 0 {
   883  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
   884  			errors = append(errors, compiler.NewError(context, message))
   885  		}
   886  		// string format = 1;
   887  		v1 := compiler.MapValueForKey(m, "format")
   888  		if v1 != nil {
   889  			x.Format, ok = compiler.StringForScalarNode(v1)
   890  			if !ok {
   891  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v1))
   892  				errors = append(errors, compiler.NewError(context, message))
   893  			}
   894  		}
   895  		// string title = 2;
   896  		v2 := compiler.MapValueForKey(m, "title")
   897  		if v2 != nil {
   898  			x.Title, ok = compiler.StringForScalarNode(v2)
   899  			if !ok {
   900  				message := fmt.Sprintf("has unexpected value for title: %s", compiler.Display(v2))
   901  				errors = append(errors, compiler.NewError(context, message))
   902  			}
   903  		}
   904  		// string description = 3;
   905  		v3 := compiler.MapValueForKey(m, "description")
   906  		if v3 != nil {
   907  			x.Description, ok = compiler.StringForScalarNode(v3)
   908  			if !ok {
   909  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
   910  				errors = append(errors, compiler.NewError(context, message))
   911  			}
   912  		}
   913  		// Any default = 4;
   914  		v4 := compiler.MapValueForKey(m, "default")
   915  		if v4 != nil {
   916  			var err error
   917  			x.Default, err = NewAny(v4, compiler.NewContext("default", v4, context))
   918  			if err != nil {
   919  				errors = append(errors, err)
   920  			}
   921  		}
   922  		// repeated string required = 5;
   923  		v5 := compiler.MapValueForKey(m, "required")
   924  		if v5 != nil {
   925  			v, ok := compiler.SequenceNodeForNode(v5)
   926  			if ok {
   927  				x.Required = compiler.StringArrayForSequenceNode(v)
   928  			} else {
   929  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v5))
   930  				errors = append(errors, compiler.NewError(context, message))
   931  			}
   932  		}
   933  		// string type = 6;
   934  		v6 := compiler.MapValueForKey(m, "type")
   935  		if v6 != nil {
   936  			x.Type, ok = compiler.StringForScalarNode(v6)
   937  			if !ok {
   938  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
   939  				errors = append(errors, compiler.NewError(context, message))
   940  			}
   941  			// check for valid enum values
   942  			// [file]
   943  			if ok && !compiler.StringArrayContainsValue([]string{"file"}, x.Type) {
   944  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
   945  				errors = append(errors, compiler.NewError(context, message))
   946  			}
   947  		}
   948  		// bool read_only = 7;
   949  		v7 := compiler.MapValueForKey(m, "readOnly")
   950  		if v7 != nil {
   951  			x.ReadOnly, ok = compiler.BoolForScalarNode(v7)
   952  			if !ok {
   953  				message := fmt.Sprintf("has unexpected value for readOnly: %s", compiler.Display(v7))
   954  				errors = append(errors, compiler.NewError(context, message))
   955  			}
   956  		}
   957  		// ExternalDocs external_docs = 8;
   958  		v8 := compiler.MapValueForKey(m, "externalDocs")
   959  		if v8 != nil {
   960  			var err error
   961  			x.ExternalDocs, err = NewExternalDocs(v8, compiler.NewContext("externalDocs", v8, context))
   962  			if err != nil {
   963  				errors = append(errors, err)
   964  			}
   965  		}
   966  		// Any example = 9;
   967  		v9 := compiler.MapValueForKey(m, "example")
   968  		if v9 != nil {
   969  			var err error
   970  			x.Example, err = NewAny(v9, compiler.NewContext("example", v9, context))
   971  			if err != nil {
   972  				errors = append(errors, err)
   973  			}
   974  		}
   975  		// repeated NamedAny vendor_extension = 10;
   976  		// MAP: Any ^x-
   977  		x.VendorExtension = make([]*NamedAny, 0)
   978  		for i := 0; i < len(m.Content); i += 2 {
   979  			k, ok := compiler.StringForScalarNode(m.Content[i])
   980  			if ok {
   981  				v := m.Content[i+1]
   982  				if strings.HasPrefix(k, "x-") {
   983  					pair := &NamedAny{}
   984  					pair.Name = k
   985  					result := &Any{}
   986  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
   987  					if handled {
   988  						if err != nil {
   989  							errors = append(errors, err)
   990  						} else {
   991  							bytes := compiler.Marshal(v)
   992  							result.Yaml = string(bytes)
   993  							result.Value = resultFromExt
   994  							pair.Value = result
   995  						}
   996  					} else {
   997  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
   998  						if err != nil {
   999  							errors = append(errors, err)
  1000  						}
  1001  					}
  1002  					x.VendorExtension = append(x.VendorExtension, pair)
  1003  				}
  1004  			}
  1005  		}
  1006  	}
  1007  	return x, compiler.NewErrorGroupOrNil(errors)
  1008  }
  1009  
  1010  // NewFormDataParameterSubSchema creates an object of type FormDataParameterSubSchema if possible, returning an error if not.
  1011  func NewFormDataParameterSubSchema(in *yaml.Node, context *compiler.Context) (*FormDataParameterSubSchema, error) {
  1012  	errors := make([]error, 0)
  1013  	x := &FormDataParameterSubSchema{}
  1014  	m, ok := compiler.UnpackMap(in)
  1015  	if !ok {
  1016  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1017  		errors = append(errors, compiler.NewError(context, message))
  1018  	} else {
  1019  		allowedKeys := []string{"allowEmptyValue", "collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
  1020  		allowedPatterns := []*regexp.Regexp{pattern0}
  1021  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  1022  		if len(invalidKeys) > 0 {
  1023  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  1024  			errors = append(errors, compiler.NewError(context, message))
  1025  		}
  1026  		// bool required = 1;
  1027  		v1 := compiler.MapValueForKey(m, "required")
  1028  		if v1 != nil {
  1029  			x.Required, ok = compiler.BoolForScalarNode(v1)
  1030  			if !ok {
  1031  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v1))
  1032  				errors = append(errors, compiler.NewError(context, message))
  1033  			}
  1034  		}
  1035  		// string in = 2;
  1036  		v2 := compiler.MapValueForKey(m, "in")
  1037  		if v2 != nil {
  1038  			x.In, ok = compiler.StringForScalarNode(v2)
  1039  			if !ok {
  1040  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  1041  				errors = append(errors, compiler.NewError(context, message))
  1042  			}
  1043  			// check for valid enum values
  1044  			// [formData]
  1045  			if ok && !compiler.StringArrayContainsValue([]string{"formData"}, x.In) {
  1046  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  1047  				errors = append(errors, compiler.NewError(context, message))
  1048  			}
  1049  		}
  1050  		// string description = 3;
  1051  		v3 := compiler.MapValueForKey(m, "description")
  1052  		if v3 != nil {
  1053  			x.Description, ok = compiler.StringForScalarNode(v3)
  1054  			if !ok {
  1055  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  1056  				errors = append(errors, compiler.NewError(context, message))
  1057  			}
  1058  		}
  1059  		// string name = 4;
  1060  		v4 := compiler.MapValueForKey(m, "name")
  1061  		if v4 != nil {
  1062  			x.Name, ok = compiler.StringForScalarNode(v4)
  1063  			if !ok {
  1064  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v4))
  1065  				errors = append(errors, compiler.NewError(context, message))
  1066  			}
  1067  		}
  1068  		// bool allow_empty_value = 5;
  1069  		v5 := compiler.MapValueForKey(m, "allowEmptyValue")
  1070  		if v5 != nil {
  1071  			x.AllowEmptyValue, ok = compiler.BoolForScalarNode(v5)
  1072  			if !ok {
  1073  				message := fmt.Sprintf("has unexpected value for allowEmptyValue: %s", compiler.Display(v5))
  1074  				errors = append(errors, compiler.NewError(context, message))
  1075  			}
  1076  		}
  1077  		// string type = 6;
  1078  		v6 := compiler.MapValueForKey(m, "type")
  1079  		if v6 != nil {
  1080  			x.Type, ok = compiler.StringForScalarNode(v6)
  1081  			if !ok {
  1082  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
  1083  				errors = append(errors, compiler.NewError(context, message))
  1084  			}
  1085  			// check for valid enum values
  1086  			// [string number boolean integer array file]
  1087  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array", "file"}, x.Type) {
  1088  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
  1089  				errors = append(errors, compiler.NewError(context, message))
  1090  			}
  1091  		}
  1092  		// string format = 7;
  1093  		v7 := compiler.MapValueForKey(m, "format")
  1094  		if v7 != nil {
  1095  			x.Format, ok = compiler.StringForScalarNode(v7)
  1096  			if !ok {
  1097  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v7))
  1098  				errors = append(errors, compiler.NewError(context, message))
  1099  			}
  1100  		}
  1101  		// PrimitivesItems items = 8;
  1102  		v8 := compiler.MapValueForKey(m, "items")
  1103  		if v8 != nil {
  1104  			var err error
  1105  			x.Items, err = NewPrimitivesItems(v8, compiler.NewContext("items", v8, context))
  1106  			if err != nil {
  1107  				errors = append(errors, err)
  1108  			}
  1109  		}
  1110  		// string collection_format = 9;
  1111  		v9 := compiler.MapValueForKey(m, "collectionFormat")
  1112  		if v9 != nil {
  1113  			x.CollectionFormat, ok = compiler.StringForScalarNode(v9)
  1114  			if !ok {
  1115  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v9))
  1116  				errors = append(errors, compiler.NewError(context, message))
  1117  			}
  1118  			// check for valid enum values
  1119  			// [csv ssv tsv pipes multi]
  1120  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes", "multi"}, x.CollectionFormat) {
  1121  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v9))
  1122  				errors = append(errors, compiler.NewError(context, message))
  1123  			}
  1124  		}
  1125  		// Any default = 10;
  1126  		v10 := compiler.MapValueForKey(m, "default")
  1127  		if v10 != nil {
  1128  			var err error
  1129  			x.Default, err = NewAny(v10, compiler.NewContext("default", v10, context))
  1130  			if err != nil {
  1131  				errors = append(errors, err)
  1132  			}
  1133  		}
  1134  		// float maximum = 11;
  1135  		v11 := compiler.MapValueForKey(m, "maximum")
  1136  		if v11 != nil {
  1137  			v, ok := compiler.FloatForScalarNode(v11)
  1138  			if ok {
  1139  				x.Maximum = v
  1140  			} else {
  1141  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v11))
  1142  				errors = append(errors, compiler.NewError(context, message))
  1143  			}
  1144  		}
  1145  		// bool exclusive_maximum = 12;
  1146  		v12 := compiler.MapValueForKey(m, "exclusiveMaximum")
  1147  		if v12 != nil {
  1148  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v12)
  1149  			if !ok {
  1150  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v12))
  1151  				errors = append(errors, compiler.NewError(context, message))
  1152  			}
  1153  		}
  1154  		// float minimum = 13;
  1155  		v13 := compiler.MapValueForKey(m, "minimum")
  1156  		if v13 != nil {
  1157  			v, ok := compiler.FloatForScalarNode(v13)
  1158  			if ok {
  1159  				x.Minimum = v
  1160  			} else {
  1161  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v13))
  1162  				errors = append(errors, compiler.NewError(context, message))
  1163  			}
  1164  		}
  1165  		// bool exclusive_minimum = 14;
  1166  		v14 := compiler.MapValueForKey(m, "exclusiveMinimum")
  1167  		if v14 != nil {
  1168  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v14)
  1169  			if !ok {
  1170  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v14))
  1171  				errors = append(errors, compiler.NewError(context, message))
  1172  			}
  1173  		}
  1174  		// int64 max_length = 15;
  1175  		v15 := compiler.MapValueForKey(m, "maxLength")
  1176  		if v15 != nil {
  1177  			t, ok := compiler.IntForScalarNode(v15)
  1178  			if ok {
  1179  				x.MaxLength = int64(t)
  1180  			} else {
  1181  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v15))
  1182  				errors = append(errors, compiler.NewError(context, message))
  1183  			}
  1184  		}
  1185  		// int64 min_length = 16;
  1186  		v16 := compiler.MapValueForKey(m, "minLength")
  1187  		if v16 != nil {
  1188  			t, ok := compiler.IntForScalarNode(v16)
  1189  			if ok {
  1190  				x.MinLength = int64(t)
  1191  			} else {
  1192  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v16))
  1193  				errors = append(errors, compiler.NewError(context, message))
  1194  			}
  1195  		}
  1196  		// string pattern = 17;
  1197  		v17 := compiler.MapValueForKey(m, "pattern")
  1198  		if v17 != nil {
  1199  			x.Pattern, ok = compiler.StringForScalarNode(v17)
  1200  			if !ok {
  1201  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v17))
  1202  				errors = append(errors, compiler.NewError(context, message))
  1203  			}
  1204  		}
  1205  		// int64 max_items = 18;
  1206  		v18 := compiler.MapValueForKey(m, "maxItems")
  1207  		if v18 != nil {
  1208  			t, ok := compiler.IntForScalarNode(v18)
  1209  			if ok {
  1210  				x.MaxItems = int64(t)
  1211  			} else {
  1212  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v18))
  1213  				errors = append(errors, compiler.NewError(context, message))
  1214  			}
  1215  		}
  1216  		// int64 min_items = 19;
  1217  		v19 := compiler.MapValueForKey(m, "minItems")
  1218  		if v19 != nil {
  1219  			t, ok := compiler.IntForScalarNode(v19)
  1220  			if ok {
  1221  				x.MinItems = int64(t)
  1222  			} else {
  1223  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v19))
  1224  				errors = append(errors, compiler.NewError(context, message))
  1225  			}
  1226  		}
  1227  		// bool unique_items = 20;
  1228  		v20 := compiler.MapValueForKey(m, "uniqueItems")
  1229  		if v20 != nil {
  1230  			x.UniqueItems, ok = compiler.BoolForScalarNode(v20)
  1231  			if !ok {
  1232  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v20))
  1233  				errors = append(errors, compiler.NewError(context, message))
  1234  			}
  1235  		}
  1236  		// repeated Any enum = 21;
  1237  		v21 := compiler.MapValueForKey(m, "enum")
  1238  		if v21 != nil {
  1239  			// repeated Any
  1240  			x.Enum = make([]*Any, 0)
  1241  			a, ok := compiler.SequenceNodeForNode(v21)
  1242  			if ok {
  1243  				for _, item := range a.Content {
  1244  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  1245  					if err != nil {
  1246  						errors = append(errors, err)
  1247  					}
  1248  					x.Enum = append(x.Enum, y)
  1249  				}
  1250  			}
  1251  		}
  1252  		// float multiple_of = 22;
  1253  		v22 := compiler.MapValueForKey(m, "multipleOf")
  1254  		if v22 != nil {
  1255  			v, ok := compiler.FloatForScalarNode(v22)
  1256  			if ok {
  1257  				x.MultipleOf = v
  1258  			} else {
  1259  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v22))
  1260  				errors = append(errors, compiler.NewError(context, message))
  1261  			}
  1262  		}
  1263  		// repeated NamedAny vendor_extension = 23;
  1264  		// MAP: Any ^x-
  1265  		x.VendorExtension = make([]*NamedAny, 0)
  1266  		for i := 0; i < len(m.Content); i += 2 {
  1267  			k, ok := compiler.StringForScalarNode(m.Content[i])
  1268  			if ok {
  1269  				v := m.Content[i+1]
  1270  				if strings.HasPrefix(k, "x-") {
  1271  					pair := &NamedAny{}
  1272  					pair.Name = k
  1273  					result := &Any{}
  1274  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  1275  					if handled {
  1276  						if err != nil {
  1277  							errors = append(errors, err)
  1278  						} else {
  1279  							bytes := compiler.Marshal(v)
  1280  							result.Yaml = string(bytes)
  1281  							result.Value = resultFromExt
  1282  							pair.Value = result
  1283  						}
  1284  					} else {
  1285  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  1286  						if err != nil {
  1287  							errors = append(errors, err)
  1288  						}
  1289  					}
  1290  					x.VendorExtension = append(x.VendorExtension, pair)
  1291  				}
  1292  			}
  1293  		}
  1294  	}
  1295  	return x, compiler.NewErrorGroupOrNil(errors)
  1296  }
  1297  
  1298  // NewHeader creates an object of type Header if possible, returning an error if not.
  1299  func NewHeader(in *yaml.Node, context *compiler.Context) (*Header, error) {
  1300  	errors := make([]error, 0)
  1301  	x := &Header{}
  1302  	m, ok := compiler.UnpackMap(in)
  1303  	if !ok {
  1304  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1305  		errors = append(errors, compiler.NewError(context, message))
  1306  	} else {
  1307  		requiredKeys := []string{"type"}
  1308  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  1309  		if len(missingKeys) > 0 {
  1310  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  1311  			errors = append(errors, compiler.NewError(context, message))
  1312  		}
  1313  		allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "pattern", "type", "uniqueItems"}
  1314  		allowedPatterns := []*regexp.Regexp{pattern0}
  1315  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  1316  		if len(invalidKeys) > 0 {
  1317  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  1318  			errors = append(errors, compiler.NewError(context, message))
  1319  		}
  1320  		// string type = 1;
  1321  		v1 := compiler.MapValueForKey(m, "type")
  1322  		if v1 != nil {
  1323  			x.Type, ok = compiler.StringForScalarNode(v1)
  1324  			if !ok {
  1325  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  1326  				errors = append(errors, compiler.NewError(context, message))
  1327  			}
  1328  			// check for valid enum values
  1329  			// [string number integer boolean array]
  1330  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "integer", "boolean", "array"}, x.Type) {
  1331  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  1332  				errors = append(errors, compiler.NewError(context, message))
  1333  			}
  1334  		}
  1335  		// string format = 2;
  1336  		v2 := compiler.MapValueForKey(m, "format")
  1337  		if v2 != nil {
  1338  			x.Format, ok = compiler.StringForScalarNode(v2)
  1339  			if !ok {
  1340  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v2))
  1341  				errors = append(errors, compiler.NewError(context, message))
  1342  			}
  1343  		}
  1344  		// PrimitivesItems items = 3;
  1345  		v3 := compiler.MapValueForKey(m, "items")
  1346  		if v3 != nil {
  1347  			var err error
  1348  			x.Items, err = NewPrimitivesItems(v3, compiler.NewContext("items", v3, context))
  1349  			if err != nil {
  1350  				errors = append(errors, err)
  1351  			}
  1352  		}
  1353  		// string collection_format = 4;
  1354  		v4 := compiler.MapValueForKey(m, "collectionFormat")
  1355  		if v4 != nil {
  1356  			x.CollectionFormat, ok = compiler.StringForScalarNode(v4)
  1357  			if !ok {
  1358  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v4))
  1359  				errors = append(errors, compiler.NewError(context, message))
  1360  			}
  1361  			// check for valid enum values
  1362  			// [csv ssv tsv pipes]
  1363  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
  1364  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v4))
  1365  				errors = append(errors, compiler.NewError(context, message))
  1366  			}
  1367  		}
  1368  		// Any default = 5;
  1369  		v5 := compiler.MapValueForKey(m, "default")
  1370  		if v5 != nil {
  1371  			var err error
  1372  			x.Default, err = NewAny(v5, compiler.NewContext("default", v5, context))
  1373  			if err != nil {
  1374  				errors = append(errors, err)
  1375  			}
  1376  		}
  1377  		// float maximum = 6;
  1378  		v6 := compiler.MapValueForKey(m, "maximum")
  1379  		if v6 != nil {
  1380  			v, ok := compiler.FloatForScalarNode(v6)
  1381  			if ok {
  1382  				x.Maximum = v
  1383  			} else {
  1384  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v6))
  1385  				errors = append(errors, compiler.NewError(context, message))
  1386  			}
  1387  		}
  1388  		// bool exclusive_maximum = 7;
  1389  		v7 := compiler.MapValueForKey(m, "exclusiveMaximum")
  1390  		if v7 != nil {
  1391  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v7)
  1392  			if !ok {
  1393  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v7))
  1394  				errors = append(errors, compiler.NewError(context, message))
  1395  			}
  1396  		}
  1397  		// float minimum = 8;
  1398  		v8 := compiler.MapValueForKey(m, "minimum")
  1399  		if v8 != nil {
  1400  			v, ok := compiler.FloatForScalarNode(v8)
  1401  			if ok {
  1402  				x.Minimum = v
  1403  			} else {
  1404  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v8))
  1405  				errors = append(errors, compiler.NewError(context, message))
  1406  			}
  1407  		}
  1408  		// bool exclusive_minimum = 9;
  1409  		v9 := compiler.MapValueForKey(m, "exclusiveMinimum")
  1410  		if v9 != nil {
  1411  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v9)
  1412  			if !ok {
  1413  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v9))
  1414  				errors = append(errors, compiler.NewError(context, message))
  1415  			}
  1416  		}
  1417  		// int64 max_length = 10;
  1418  		v10 := compiler.MapValueForKey(m, "maxLength")
  1419  		if v10 != nil {
  1420  			t, ok := compiler.IntForScalarNode(v10)
  1421  			if ok {
  1422  				x.MaxLength = int64(t)
  1423  			} else {
  1424  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v10))
  1425  				errors = append(errors, compiler.NewError(context, message))
  1426  			}
  1427  		}
  1428  		// int64 min_length = 11;
  1429  		v11 := compiler.MapValueForKey(m, "minLength")
  1430  		if v11 != nil {
  1431  			t, ok := compiler.IntForScalarNode(v11)
  1432  			if ok {
  1433  				x.MinLength = int64(t)
  1434  			} else {
  1435  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v11))
  1436  				errors = append(errors, compiler.NewError(context, message))
  1437  			}
  1438  		}
  1439  		// string pattern = 12;
  1440  		v12 := compiler.MapValueForKey(m, "pattern")
  1441  		if v12 != nil {
  1442  			x.Pattern, ok = compiler.StringForScalarNode(v12)
  1443  			if !ok {
  1444  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v12))
  1445  				errors = append(errors, compiler.NewError(context, message))
  1446  			}
  1447  		}
  1448  		// int64 max_items = 13;
  1449  		v13 := compiler.MapValueForKey(m, "maxItems")
  1450  		if v13 != nil {
  1451  			t, ok := compiler.IntForScalarNode(v13)
  1452  			if ok {
  1453  				x.MaxItems = int64(t)
  1454  			} else {
  1455  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v13))
  1456  				errors = append(errors, compiler.NewError(context, message))
  1457  			}
  1458  		}
  1459  		// int64 min_items = 14;
  1460  		v14 := compiler.MapValueForKey(m, "minItems")
  1461  		if v14 != nil {
  1462  			t, ok := compiler.IntForScalarNode(v14)
  1463  			if ok {
  1464  				x.MinItems = int64(t)
  1465  			} else {
  1466  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v14))
  1467  				errors = append(errors, compiler.NewError(context, message))
  1468  			}
  1469  		}
  1470  		// bool unique_items = 15;
  1471  		v15 := compiler.MapValueForKey(m, "uniqueItems")
  1472  		if v15 != nil {
  1473  			x.UniqueItems, ok = compiler.BoolForScalarNode(v15)
  1474  			if !ok {
  1475  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v15))
  1476  				errors = append(errors, compiler.NewError(context, message))
  1477  			}
  1478  		}
  1479  		// repeated Any enum = 16;
  1480  		v16 := compiler.MapValueForKey(m, "enum")
  1481  		if v16 != nil {
  1482  			// repeated Any
  1483  			x.Enum = make([]*Any, 0)
  1484  			a, ok := compiler.SequenceNodeForNode(v16)
  1485  			if ok {
  1486  				for _, item := range a.Content {
  1487  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  1488  					if err != nil {
  1489  						errors = append(errors, err)
  1490  					}
  1491  					x.Enum = append(x.Enum, y)
  1492  				}
  1493  			}
  1494  		}
  1495  		// float multiple_of = 17;
  1496  		v17 := compiler.MapValueForKey(m, "multipleOf")
  1497  		if v17 != nil {
  1498  			v, ok := compiler.FloatForScalarNode(v17)
  1499  			if ok {
  1500  				x.MultipleOf = v
  1501  			} else {
  1502  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v17))
  1503  				errors = append(errors, compiler.NewError(context, message))
  1504  			}
  1505  		}
  1506  		// string description = 18;
  1507  		v18 := compiler.MapValueForKey(m, "description")
  1508  		if v18 != nil {
  1509  			x.Description, ok = compiler.StringForScalarNode(v18)
  1510  			if !ok {
  1511  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v18))
  1512  				errors = append(errors, compiler.NewError(context, message))
  1513  			}
  1514  		}
  1515  		// repeated NamedAny vendor_extension = 19;
  1516  		// MAP: Any ^x-
  1517  		x.VendorExtension = make([]*NamedAny, 0)
  1518  		for i := 0; i < len(m.Content); i += 2 {
  1519  			k, ok := compiler.StringForScalarNode(m.Content[i])
  1520  			if ok {
  1521  				v := m.Content[i+1]
  1522  				if strings.HasPrefix(k, "x-") {
  1523  					pair := &NamedAny{}
  1524  					pair.Name = k
  1525  					result := &Any{}
  1526  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  1527  					if handled {
  1528  						if err != nil {
  1529  							errors = append(errors, err)
  1530  						} else {
  1531  							bytes := compiler.Marshal(v)
  1532  							result.Yaml = string(bytes)
  1533  							result.Value = resultFromExt
  1534  							pair.Value = result
  1535  						}
  1536  					} else {
  1537  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  1538  						if err != nil {
  1539  							errors = append(errors, err)
  1540  						}
  1541  					}
  1542  					x.VendorExtension = append(x.VendorExtension, pair)
  1543  				}
  1544  			}
  1545  		}
  1546  	}
  1547  	return x, compiler.NewErrorGroupOrNil(errors)
  1548  }
  1549  
  1550  // NewHeaderParameterSubSchema creates an object of type HeaderParameterSubSchema if possible, returning an error if not.
  1551  func NewHeaderParameterSubSchema(in *yaml.Node, context *compiler.Context) (*HeaderParameterSubSchema, error) {
  1552  	errors := make([]error, 0)
  1553  	x := &HeaderParameterSubSchema{}
  1554  	m, ok := compiler.UnpackMap(in)
  1555  	if !ok {
  1556  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1557  		errors = append(errors, compiler.NewError(context, message))
  1558  	} else {
  1559  		allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
  1560  		allowedPatterns := []*regexp.Regexp{pattern0}
  1561  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  1562  		if len(invalidKeys) > 0 {
  1563  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  1564  			errors = append(errors, compiler.NewError(context, message))
  1565  		}
  1566  		// bool required = 1;
  1567  		v1 := compiler.MapValueForKey(m, "required")
  1568  		if v1 != nil {
  1569  			x.Required, ok = compiler.BoolForScalarNode(v1)
  1570  			if !ok {
  1571  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v1))
  1572  				errors = append(errors, compiler.NewError(context, message))
  1573  			}
  1574  		}
  1575  		// string in = 2;
  1576  		v2 := compiler.MapValueForKey(m, "in")
  1577  		if v2 != nil {
  1578  			x.In, ok = compiler.StringForScalarNode(v2)
  1579  			if !ok {
  1580  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  1581  				errors = append(errors, compiler.NewError(context, message))
  1582  			}
  1583  			// check for valid enum values
  1584  			// [header]
  1585  			if ok && !compiler.StringArrayContainsValue([]string{"header"}, x.In) {
  1586  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  1587  				errors = append(errors, compiler.NewError(context, message))
  1588  			}
  1589  		}
  1590  		// string description = 3;
  1591  		v3 := compiler.MapValueForKey(m, "description")
  1592  		if v3 != nil {
  1593  			x.Description, ok = compiler.StringForScalarNode(v3)
  1594  			if !ok {
  1595  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  1596  				errors = append(errors, compiler.NewError(context, message))
  1597  			}
  1598  		}
  1599  		// string name = 4;
  1600  		v4 := compiler.MapValueForKey(m, "name")
  1601  		if v4 != nil {
  1602  			x.Name, ok = compiler.StringForScalarNode(v4)
  1603  			if !ok {
  1604  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v4))
  1605  				errors = append(errors, compiler.NewError(context, message))
  1606  			}
  1607  		}
  1608  		// string type = 5;
  1609  		v5 := compiler.MapValueForKey(m, "type")
  1610  		if v5 != nil {
  1611  			x.Type, ok = compiler.StringForScalarNode(v5)
  1612  			if !ok {
  1613  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v5))
  1614  				errors = append(errors, compiler.NewError(context, message))
  1615  			}
  1616  			// check for valid enum values
  1617  			// [string number boolean integer array]
  1618  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
  1619  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v5))
  1620  				errors = append(errors, compiler.NewError(context, message))
  1621  			}
  1622  		}
  1623  		// string format = 6;
  1624  		v6 := compiler.MapValueForKey(m, "format")
  1625  		if v6 != nil {
  1626  			x.Format, ok = compiler.StringForScalarNode(v6)
  1627  			if !ok {
  1628  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v6))
  1629  				errors = append(errors, compiler.NewError(context, message))
  1630  			}
  1631  		}
  1632  		// PrimitivesItems items = 7;
  1633  		v7 := compiler.MapValueForKey(m, "items")
  1634  		if v7 != nil {
  1635  			var err error
  1636  			x.Items, err = NewPrimitivesItems(v7, compiler.NewContext("items", v7, context))
  1637  			if err != nil {
  1638  				errors = append(errors, err)
  1639  			}
  1640  		}
  1641  		// string collection_format = 8;
  1642  		v8 := compiler.MapValueForKey(m, "collectionFormat")
  1643  		if v8 != nil {
  1644  			x.CollectionFormat, ok = compiler.StringForScalarNode(v8)
  1645  			if !ok {
  1646  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v8))
  1647  				errors = append(errors, compiler.NewError(context, message))
  1648  			}
  1649  			// check for valid enum values
  1650  			// [csv ssv tsv pipes]
  1651  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
  1652  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v8))
  1653  				errors = append(errors, compiler.NewError(context, message))
  1654  			}
  1655  		}
  1656  		// Any default = 9;
  1657  		v9 := compiler.MapValueForKey(m, "default")
  1658  		if v9 != nil {
  1659  			var err error
  1660  			x.Default, err = NewAny(v9, compiler.NewContext("default", v9, context))
  1661  			if err != nil {
  1662  				errors = append(errors, err)
  1663  			}
  1664  		}
  1665  		// float maximum = 10;
  1666  		v10 := compiler.MapValueForKey(m, "maximum")
  1667  		if v10 != nil {
  1668  			v, ok := compiler.FloatForScalarNode(v10)
  1669  			if ok {
  1670  				x.Maximum = v
  1671  			} else {
  1672  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v10))
  1673  				errors = append(errors, compiler.NewError(context, message))
  1674  			}
  1675  		}
  1676  		// bool exclusive_maximum = 11;
  1677  		v11 := compiler.MapValueForKey(m, "exclusiveMaximum")
  1678  		if v11 != nil {
  1679  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v11)
  1680  			if !ok {
  1681  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v11))
  1682  				errors = append(errors, compiler.NewError(context, message))
  1683  			}
  1684  		}
  1685  		// float minimum = 12;
  1686  		v12 := compiler.MapValueForKey(m, "minimum")
  1687  		if v12 != nil {
  1688  			v, ok := compiler.FloatForScalarNode(v12)
  1689  			if ok {
  1690  				x.Minimum = v
  1691  			} else {
  1692  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v12))
  1693  				errors = append(errors, compiler.NewError(context, message))
  1694  			}
  1695  		}
  1696  		// bool exclusive_minimum = 13;
  1697  		v13 := compiler.MapValueForKey(m, "exclusiveMinimum")
  1698  		if v13 != nil {
  1699  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v13)
  1700  			if !ok {
  1701  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v13))
  1702  				errors = append(errors, compiler.NewError(context, message))
  1703  			}
  1704  		}
  1705  		// int64 max_length = 14;
  1706  		v14 := compiler.MapValueForKey(m, "maxLength")
  1707  		if v14 != nil {
  1708  			t, ok := compiler.IntForScalarNode(v14)
  1709  			if ok {
  1710  				x.MaxLength = int64(t)
  1711  			} else {
  1712  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v14))
  1713  				errors = append(errors, compiler.NewError(context, message))
  1714  			}
  1715  		}
  1716  		// int64 min_length = 15;
  1717  		v15 := compiler.MapValueForKey(m, "minLength")
  1718  		if v15 != nil {
  1719  			t, ok := compiler.IntForScalarNode(v15)
  1720  			if ok {
  1721  				x.MinLength = int64(t)
  1722  			} else {
  1723  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v15))
  1724  				errors = append(errors, compiler.NewError(context, message))
  1725  			}
  1726  		}
  1727  		// string pattern = 16;
  1728  		v16 := compiler.MapValueForKey(m, "pattern")
  1729  		if v16 != nil {
  1730  			x.Pattern, ok = compiler.StringForScalarNode(v16)
  1731  			if !ok {
  1732  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v16))
  1733  				errors = append(errors, compiler.NewError(context, message))
  1734  			}
  1735  		}
  1736  		// int64 max_items = 17;
  1737  		v17 := compiler.MapValueForKey(m, "maxItems")
  1738  		if v17 != nil {
  1739  			t, ok := compiler.IntForScalarNode(v17)
  1740  			if ok {
  1741  				x.MaxItems = int64(t)
  1742  			} else {
  1743  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v17))
  1744  				errors = append(errors, compiler.NewError(context, message))
  1745  			}
  1746  		}
  1747  		// int64 min_items = 18;
  1748  		v18 := compiler.MapValueForKey(m, "minItems")
  1749  		if v18 != nil {
  1750  			t, ok := compiler.IntForScalarNode(v18)
  1751  			if ok {
  1752  				x.MinItems = int64(t)
  1753  			} else {
  1754  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v18))
  1755  				errors = append(errors, compiler.NewError(context, message))
  1756  			}
  1757  		}
  1758  		// bool unique_items = 19;
  1759  		v19 := compiler.MapValueForKey(m, "uniqueItems")
  1760  		if v19 != nil {
  1761  			x.UniqueItems, ok = compiler.BoolForScalarNode(v19)
  1762  			if !ok {
  1763  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v19))
  1764  				errors = append(errors, compiler.NewError(context, message))
  1765  			}
  1766  		}
  1767  		// repeated Any enum = 20;
  1768  		v20 := compiler.MapValueForKey(m, "enum")
  1769  		if v20 != nil {
  1770  			// repeated Any
  1771  			x.Enum = make([]*Any, 0)
  1772  			a, ok := compiler.SequenceNodeForNode(v20)
  1773  			if ok {
  1774  				for _, item := range a.Content {
  1775  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  1776  					if err != nil {
  1777  						errors = append(errors, err)
  1778  					}
  1779  					x.Enum = append(x.Enum, y)
  1780  				}
  1781  			}
  1782  		}
  1783  		// float multiple_of = 21;
  1784  		v21 := compiler.MapValueForKey(m, "multipleOf")
  1785  		if v21 != nil {
  1786  			v, ok := compiler.FloatForScalarNode(v21)
  1787  			if ok {
  1788  				x.MultipleOf = v
  1789  			} else {
  1790  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v21))
  1791  				errors = append(errors, compiler.NewError(context, message))
  1792  			}
  1793  		}
  1794  		// repeated NamedAny vendor_extension = 22;
  1795  		// MAP: Any ^x-
  1796  		x.VendorExtension = make([]*NamedAny, 0)
  1797  		for i := 0; i < len(m.Content); i += 2 {
  1798  			k, ok := compiler.StringForScalarNode(m.Content[i])
  1799  			if ok {
  1800  				v := m.Content[i+1]
  1801  				if strings.HasPrefix(k, "x-") {
  1802  					pair := &NamedAny{}
  1803  					pair.Name = k
  1804  					result := &Any{}
  1805  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  1806  					if handled {
  1807  						if err != nil {
  1808  							errors = append(errors, err)
  1809  						} else {
  1810  							bytes := compiler.Marshal(v)
  1811  							result.Yaml = string(bytes)
  1812  							result.Value = resultFromExt
  1813  							pair.Value = result
  1814  						}
  1815  					} else {
  1816  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  1817  						if err != nil {
  1818  							errors = append(errors, err)
  1819  						}
  1820  					}
  1821  					x.VendorExtension = append(x.VendorExtension, pair)
  1822  				}
  1823  			}
  1824  		}
  1825  	}
  1826  	return x, compiler.NewErrorGroupOrNil(errors)
  1827  }
  1828  
  1829  // NewHeaders creates an object of type Headers if possible, returning an error if not.
  1830  func NewHeaders(in *yaml.Node, context *compiler.Context) (*Headers, error) {
  1831  	errors := make([]error, 0)
  1832  	x := &Headers{}
  1833  	m, ok := compiler.UnpackMap(in)
  1834  	if !ok {
  1835  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1836  		errors = append(errors, compiler.NewError(context, message))
  1837  	} else {
  1838  		// repeated NamedHeader additional_properties = 1;
  1839  		// MAP: Header
  1840  		x.AdditionalProperties = make([]*NamedHeader, 0)
  1841  		for i := 0; i < len(m.Content); i += 2 {
  1842  			k, ok := compiler.StringForScalarNode(m.Content[i])
  1843  			if ok {
  1844  				v := m.Content[i+1]
  1845  				pair := &NamedHeader{}
  1846  				pair.Name = k
  1847  				var err error
  1848  				pair.Value, err = NewHeader(v, compiler.NewContext(k, v, context))
  1849  				if err != nil {
  1850  					errors = append(errors, err)
  1851  				}
  1852  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  1853  			}
  1854  		}
  1855  	}
  1856  	return x, compiler.NewErrorGroupOrNil(errors)
  1857  }
  1858  
  1859  // NewInfo creates an object of type Info if possible, returning an error if not.
  1860  func NewInfo(in *yaml.Node, context *compiler.Context) (*Info, error) {
  1861  	errors := make([]error, 0)
  1862  	x := &Info{}
  1863  	m, ok := compiler.UnpackMap(in)
  1864  	if !ok {
  1865  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1866  		errors = append(errors, compiler.NewError(context, message))
  1867  	} else {
  1868  		requiredKeys := []string{"title", "version"}
  1869  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  1870  		if len(missingKeys) > 0 {
  1871  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  1872  			errors = append(errors, compiler.NewError(context, message))
  1873  		}
  1874  		allowedKeys := []string{"contact", "description", "license", "termsOfService", "title", "version"}
  1875  		allowedPatterns := []*regexp.Regexp{pattern0}
  1876  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  1877  		if len(invalidKeys) > 0 {
  1878  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  1879  			errors = append(errors, compiler.NewError(context, message))
  1880  		}
  1881  		// string title = 1;
  1882  		v1 := compiler.MapValueForKey(m, "title")
  1883  		if v1 != nil {
  1884  			x.Title, ok = compiler.StringForScalarNode(v1)
  1885  			if !ok {
  1886  				message := fmt.Sprintf("has unexpected value for title: %s", compiler.Display(v1))
  1887  				errors = append(errors, compiler.NewError(context, message))
  1888  			}
  1889  		}
  1890  		// string version = 2;
  1891  		v2 := compiler.MapValueForKey(m, "version")
  1892  		if v2 != nil {
  1893  			x.Version, ok = compiler.StringForScalarNode(v2)
  1894  			if !ok {
  1895  				message := fmt.Sprintf("has unexpected value for version: %s", compiler.Display(v2))
  1896  				errors = append(errors, compiler.NewError(context, message))
  1897  			}
  1898  		}
  1899  		// string description = 3;
  1900  		v3 := compiler.MapValueForKey(m, "description")
  1901  		if v3 != nil {
  1902  			x.Description, ok = compiler.StringForScalarNode(v3)
  1903  			if !ok {
  1904  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  1905  				errors = append(errors, compiler.NewError(context, message))
  1906  			}
  1907  		}
  1908  		// string terms_of_service = 4;
  1909  		v4 := compiler.MapValueForKey(m, "termsOfService")
  1910  		if v4 != nil {
  1911  			x.TermsOfService, ok = compiler.StringForScalarNode(v4)
  1912  			if !ok {
  1913  				message := fmt.Sprintf("has unexpected value for termsOfService: %s", compiler.Display(v4))
  1914  				errors = append(errors, compiler.NewError(context, message))
  1915  			}
  1916  		}
  1917  		// Contact contact = 5;
  1918  		v5 := compiler.MapValueForKey(m, "contact")
  1919  		if v5 != nil {
  1920  			var err error
  1921  			x.Contact, err = NewContact(v5, compiler.NewContext("contact", v5, context))
  1922  			if err != nil {
  1923  				errors = append(errors, err)
  1924  			}
  1925  		}
  1926  		// License license = 6;
  1927  		v6 := compiler.MapValueForKey(m, "license")
  1928  		if v6 != nil {
  1929  			var err error
  1930  			x.License, err = NewLicense(v6, compiler.NewContext("license", v6, context))
  1931  			if err != nil {
  1932  				errors = append(errors, err)
  1933  			}
  1934  		}
  1935  		// repeated NamedAny vendor_extension = 7;
  1936  		// MAP: Any ^x-
  1937  		x.VendorExtension = make([]*NamedAny, 0)
  1938  		for i := 0; i < len(m.Content); i += 2 {
  1939  			k, ok := compiler.StringForScalarNode(m.Content[i])
  1940  			if ok {
  1941  				v := m.Content[i+1]
  1942  				if strings.HasPrefix(k, "x-") {
  1943  					pair := &NamedAny{}
  1944  					pair.Name = k
  1945  					result := &Any{}
  1946  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  1947  					if handled {
  1948  						if err != nil {
  1949  							errors = append(errors, err)
  1950  						} else {
  1951  							bytes := compiler.Marshal(v)
  1952  							result.Yaml = string(bytes)
  1953  							result.Value = resultFromExt
  1954  							pair.Value = result
  1955  						}
  1956  					} else {
  1957  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  1958  						if err != nil {
  1959  							errors = append(errors, err)
  1960  						}
  1961  					}
  1962  					x.VendorExtension = append(x.VendorExtension, pair)
  1963  				}
  1964  			}
  1965  		}
  1966  	}
  1967  	return x, compiler.NewErrorGroupOrNil(errors)
  1968  }
  1969  
  1970  // NewItemsItem creates an object of type ItemsItem if possible, returning an error if not.
  1971  func NewItemsItem(in *yaml.Node, context *compiler.Context) (*ItemsItem, error) {
  1972  	errors := make([]error, 0)
  1973  	x := &ItemsItem{}
  1974  	m, ok := compiler.UnpackMap(in)
  1975  	if !ok {
  1976  		message := fmt.Sprintf("has unexpected value for item array: %+v (%T)", in, in)
  1977  		errors = append(errors, compiler.NewError(context, message))
  1978  	} else {
  1979  		x.Schema = make([]*Schema, 0)
  1980  		y, err := NewSchema(m, compiler.NewContext("<array>", m, context))
  1981  		if err != nil {
  1982  			return nil, err
  1983  		}
  1984  		x.Schema = append(x.Schema, y)
  1985  	}
  1986  	return x, compiler.NewErrorGroupOrNil(errors)
  1987  }
  1988  
  1989  // NewJsonReference creates an object of type JsonReference if possible, returning an error if not.
  1990  func NewJsonReference(in *yaml.Node, context *compiler.Context) (*JsonReference, error) {
  1991  	errors := make([]error, 0)
  1992  	x := &JsonReference{}
  1993  	m, ok := compiler.UnpackMap(in)
  1994  	if !ok {
  1995  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  1996  		errors = append(errors, compiler.NewError(context, message))
  1997  	} else {
  1998  		requiredKeys := []string{"$ref"}
  1999  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2000  		if len(missingKeys) > 0 {
  2001  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2002  			errors = append(errors, compiler.NewError(context, message))
  2003  		}
  2004  		// string _ref = 1;
  2005  		v1 := compiler.MapValueForKey(m, "$ref")
  2006  		if v1 != nil {
  2007  			x.XRef, ok = compiler.StringForScalarNode(v1)
  2008  			if !ok {
  2009  				message := fmt.Sprintf("has unexpected value for $ref: %s", compiler.Display(v1))
  2010  				errors = append(errors, compiler.NewError(context, message))
  2011  			}
  2012  		}
  2013  		// string description = 2;
  2014  		v2 := compiler.MapValueForKey(m, "description")
  2015  		if v2 != nil {
  2016  			x.Description, ok = compiler.StringForScalarNode(v2)
  2017  			if !ok {
  2018  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
  2019  				errors = append(errors, compiler.NewError(context, message))
  2020  			}
  2021  		}
  2022  	}
  2023  	return x, compiler.NewErrorGroupOrNil(errors)
  2024  }
  2025  
  2026  // NewLicense creates an object of type License if possible, returning an error if not.
  2027  func NewLicense(in *yaml.Node, context *compiler.Context) (*License, error) {
  2028  	errors := make([]error, 0)
  2029  	x := &License{}
  2030  	m, ok := compiler.UnpackMap(in)
  2031  	if !ok {
  2032  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2033  		errors = append(errors, compiler.NewError(context, message))
  2034  	} else {
  2035  		requiredKeys := []string{"name"}
  2036  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2037  		if len(missingKeys) > 0 {
  2038  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2039  			errors = append(errors, compiler.NewError(context, message))
  2040  		}
  2041  		allowedKeys := []string{"name", "url"}
  2042  		allowedPatterns := []*regexp.Regexp{pattern0}
  2043  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2044  		if len(invalidKeys) > 0 {
  2045  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2046  			errors = append(errors, compiler.NewError(context, message))
  2047  		}
  2048  		// string name = 1;
  2049  		v1 := compiler.MapValueForKey(m, "name")
  2050  		if v1 != nil {
  2051  			x.Name, ok = compiler.StringForScalarNode(v1)
  2052  			if !ok {
  2053  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2054  				errors = append(errors, compiler.NewError(context, message))
  2055  			}
  2056  		}
  2057  		// string url = 2;
  2058  		v2 := compiler.MapValueForKey(m, "url")
  2059  		if v2 != nil {
  2060  			x.Url, ok = compiler.StringForScalarNode(v2)
  2061  			if !ok {
  2062  				message := fmt.Sprintf("has unexpected value for url: %s", compiler.Display(v2))
  2063  				errors = append(errors, compiler.NewError(context, message))
  2064  			}
  2065  		}
  2066  		// repeated NamedAny vendor_extension = 3;
  2067  		// MAP: Any ^x-
  2068  		x.VendorExtension = make([]*NamedAny, 0)
  2069  		for i := 0; i < len(m.Content); i += 2 {
  2070  			k, ok := compiler.StringForScalarNode(m.Content[i])
  2071  			if ok {
  2072  				v := m.Content[i+1]
  2073  				if strings.HasPrefix(k, "x-") {
  2074  					pair := &NamedAny{}
  2075  					pair.Name = k
  2076  					result := &Any{}
  2077  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  2078  					if handled {
  2079  						if err != nil {
  2080  							errors = append(errors, err)
  2081  						} else {
  2082  							bytes := compiler.Marshal(v)
  2083  							result.Yaml = string(bytes)
  2084  							result.Value = resultFromExt
  2085  							pair.Value = result
  2086  						}
  2087  					} else {
  2088  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  2089  						if err != nil {
  2090  							errors = append(errors, err)
  2091  						}
  2092  					}
  2093  					x.VendorExtension = append(x.VendorExtension, pair)
  2094  				}
  2095  			}
  2096  		}
  2097  	}
  2098  	return x, compiler.NewErrorGroupOrNil(errors)
  2099  }
  2100  
  2101  // NewNamedAny creates an object of type NamedAny if possible, returning an error if not.
  2102  func NewNamedAny(in *yaml.Node, context *compiler.Context) (*NamedAny, error) {
  2103  	errors := make([]error, 0)
  2104  	x := &NamedAny{}
  2105  	m, ok := compiler.UnpackMap(in)
  2106  	if !ok {
  2107  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2108  		errors = append(errors, compiler.NewError(context, message))
  2109  	} else {
  2110  		allowedKeys := []string{"name", "value"}
  2111  		var allowedPatterns []*regexp.Regexp
  2112  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2113  		if len(invalidKeys) > 0 {
  2114  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2115  			errors = append(errors, compiler.NewError(context, message))
  2116  		}
  2117  		// string name = 1;
  2118  		v1 := compiler.MapValueForKey(m, "name")
  2119  		if v1 != nil {
  2120  			x.Name, ok = compiler.StringForScalarNode(v1)
  2121  			if !ok {
  2122  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2123  				errors = append(errors, compiler.NewError(context, message))
  2124  			}
  2125  		}
  2126  		// Any value = 2;
  2127  		v2 := compiler.MapValueForKey(m, "value")
  2128  		if v2 != nil {
  2129  			var err error
  2130  			x.Value, err = NewAny(v2, compiler.NewContext("value", v2, context))
  2131  			if err != nil {
  2132  				errors = append(errors, err)
  2133  			}
  2134  		}
  2135  	}
  2136  	return x, compiler.NewErrorGroupOrNil(errors)
  2137  }
  2138  
  2139  // NewNamedHeader creates an object of type NamedHeader if possible, returning an error if not.
  2140  func NewNamedHeader(in *yaml.Node, context *compiler.Context) (*NamedHeader, error) {
  2141  	errors := make([]error, 0)
  2142  	x := &NamedHeader{}
  2143  	m, ok := compiler.UnpackMap(in)
  2144  	if !ok {
  2145  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2146  		errors = append(errors, compiler.NewError(context, message))
  2147  	} else {
  2148  		allowedKeys := []string{"name", "value"}
  2149  		var allowedPatterns []*regexp.Regexp
  2150  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2151  		if len(invalidKeys) > 0 {
  2152  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2153  			errors = append(errors, compiler.NewError(context, message))
  2154  		}
  2155  		// string name = 1;
  2156  		v1 := compiler.MapValueForKey(m, "name")
  2157  		if v1 != nil {
  2158  			x.Name, ok = compiler.StringForScalarNode(v1)
  2159  			if !ok {
  2160  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2161  				errors = append(errors, compiler.NewError(context, message))
  2162  			}
  2163  		}
  2164  		// Header value = 2;
  2165  		v2 := compiler.MapValueForKey(m, "value")
  2166  		if v2 != nil {
  2167  			var err error
  2168  			x.Value, err = NewHeader(v2, compiler.NewContext("value", v2, context))
  2169  			if err != nil {
  2170  				errors = append(errors, err)
  2171  			}
  2172  		}
  2173  	}
  2174  	return x, compiler.NewErrorGroupOrNil(errors)
  2175  }
  2176  
  2177  // NewNamedParameter creates an object of type NamedParameter if possible, returning an error if not.
  2178  func NewNamedParameter(in *yaml.Node, context *compiler.Context) (*NamedParameter, error) {
  2179  	errors := make([]error, 0)
  2180  	x := &NamedParameter{}
  2181  	m, ok := compiler.UnpackMap(in)
  2182  	if !ok {
  2183  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2184  		errors = append(errors, compiler.NewError(context, message))
  2185  	} else {
  2186  		allowedKeys := []string{"name", "value"}
  2187  		var allowedPatterns []*regexp.Regexp
  2188  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2189  		if len(invalidKeys) > 0 {
  2190  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2191  			errors = append(errors, compiler.NewError(context, message))
  2192  		}
  2193  		// string name = 1;
  2194  		v1 := compiler.MapValueForKey(m, "name")
  2195  		if v1 != nil {
  2196  			x.Name, ok = compiler.StringForScalarNode(v1)
  2197  			if !ok {
  2198  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2199  				errors = append(errors, compiler.NewError(context, message))
  2200  			}
  2201  		}
  2202  		// Parameter value = 2;
  2203  		v2 := compiler.MapValueForKey(m, "value")
  2204  		if v2 != nil {
  2205  			var err error
  2206  			x.Value, err = NewParameter(v2, compiler.NewContext("value", v2, context))
  2207  			if err != nil {
  2208  				errors = append(errors, err)
  2209  			}
  2210  		}
  2211  	}
  2212  	return x, compiler.NewErrorGroupOrNil(errors)
  2213  }
  2214  
  2215  // NewNamedPathItem creates an object of type NamedPathItem if possible, returning an error if not.
  2216  func NewNamedPathItem(in *yaml.Node, context *compiler.Context) (*NamedPathItem, error) {
  2217  	errors := make([]error, 0)
  2218  	x := &NamedPathItem{}
  2219  	m, ok := compiler.UnpackMap(in)
  2220  	if !ok {
  2221  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2222  		errors = append(errors, compiler.NewError(context, message))
  2223  	} else {
  2224  		allowedKeys := []string{"name", "value"}
  2225  		var allowedPatterns []*regexp.Regexp
  2226  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2227  		if len(invalidKeys) > 0 {
  2228  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2229  			errors = append(errors, compiler.NewError(context, message))
  2230  		}
  2231  		// string name = 1;
  2232  		v1 := compiler.MapValueForKey(m, "name")
  2233  		if v1 != nil {
  2234  			x.Name, ok = compiler.StringForScalarNode(v1)
  2235  			if !ok {
  2236  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2237  				errors = append(errors, compiler.NewError(context, message))
  2238  			}
  2239  		}
  2240  		// PathItem value = 2;
  2241  		v2 := compiler.MapValueForKey(m, "value")
  2242  		if v2 != nil {
  2243  			var err error
  2244  			x.Value, err = NewPathItem(v2, compiler.NewContext("value", v2, context))
  2245  			if err != nil {
  2246  				errors = append(errors, err)
  2247  			}
  2248  		}
  2249  	}
  2250  	return x, compiler.NewErrorGroupOrNil(errors)
  2251  }
  2252  
  2253  // NewNamedResponse creates an object of type NamedResponse if possible, returning an error if not.
  2254  func NewNamedResponse(in *yaml.Node, context *compiler.Context) (*NamedResponse, error) {
  2255  	errors := make([]error, 0)
  2256  	x := &NamedResponse{}
  2257  	m, ok := compiler.UnpackMap(in)
  2258  	if !ok {
  2259  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2260  		errors = append(errors, compiler.NewError(context, message))
  2261  	} else {
  2262  		allowedKeys := []string{"name", "value"}
  2263  		var allowedPatterns []*regexp.Regexp
  2264  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2265  		if len(invalidKeys) > 0 {
  2266  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2267  			errors = append(errors, compiler.NewError(context, message))
  2268  		}
  2269  		// string name = 1;
  2270  		v1 := compiler.MapValueForKey(m, "name")
  2271  		if v1 != nil {
  2272  			x.Name, ok = compiler.StringForScalarNode(v1)
  2273  			if !ok {
  2274  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2275  				errors = append(errors, compiler.NewError(context, message))
  2276  			}
  2277  		}
  2278  		// Response value = 2;
  2279  		v2 := compiler.MapValueForKey(m, "value")
  2280  		if v2 != nil {
  2281  			var err error
  2282  			x.Value, err = NewResponse(v2, compiler.NewContext("value", v2, context))
  2283  			if err != nil {
  2284  				errors = append(errors, err)
  2285  			}
  2286  		}
  2287  	}
  2288  	return x, compiler.NewErrorGroupOrNil(errors)
  2289  }
  2290  
  2291  // NewNamedResponseValue creates an object of type NamedResponseValue if possible, returning an error if not.
  2292  func NewNamedResponseValue(in *yaml.Node, context *compiler.Context) (*NamedResponseValue, error) {
  2293  	errors := make([]error, 0)
  2294  	x := &NamedResponseValue{}
  2295  	m, ok := compiler.UnpackMap(in)
  2296  	if !ok {
  2297  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2298  		errors = append(errors, compiler.NewError(context, message))
  2299  	} else {
  2300  		allowedKeys := []string{"name", "value"}
  2301  		var allowedPatterns []*regexp.Regexp
  2302  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2303  		if len(invalidKeys) > 0 {
  2304  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2305  			errors = append(errors, compiler.NewError(context, message))
  2306  		}
  2307  		// string name = 1;
  2308  		v1 := compiler.MapValueForKey(m, "name")
  2309  		if v1 != nil {
  2310  			x.Name, ok = compiler.StringForScalarNode(v1)
  2311  			if !ok {
  2312  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2313  				errors = append(errors, compiler.NewError(context, message))
  2314  			}
  2315  		}
  2316  		// ResponseValue value = 2;
  2317  		v2 := compiler.MapValueForKey(m, "value")
  2318  		if v2 != nil {
  2319  			var err error
  2320  			x.Value, err = NewResponseValue(v2, compiler.NewContext("value", v2, context))
  2321  			if err != nil {
  2322  				errors = append(errors, err)
  2323  			}
  2324  		}
  2325  	}
  2326  	return x, compiler.NewErrorGroupOrNil(errors)
  2327  }
  2328  
  2329  // NewNamedSchema creates an object of type NamedSchema if possible, returning an error if not.
  2330  func NewNamedSchema(in *yaml.Node, context *compiler.Context) (*NamedSchema, error) {
  2331  	errors := make([]error, 0)
  2332  	x := &NamedSchema{}
  2333  	m, ok := compiler.UnpackMap(in)
  2334  	if !ok {
  2335  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2336  		errors = append(errors, compiler.NewError(context, message))
  2337  	} else {
  2338  		allowedKeys := []string{"name", "value"}
  2339  		var allowedPatterns []*regexp.Regexp
  2340  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2341  		if len(invalidKeys) > 0 {
  2342  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2343  			errors = append(errors, compiler.NewError(context, message))
  2344  		}
  2345  		// string name = 1;
  2346  		v1 := compiler.MapValueForKey(m, "name")
  2347  		if v1 != nil {
  2348  			x.Name, ok = compiler.StringForScalarNode(v1)
  2349  			if !ok {
  2350  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2351  				errors = append(errors, compiler.NewError(context, message))
  2352  			}
  2353  		}
  2354  		// Schema value = 2;
  2355  		v2 := compiler.MapValueForKey(m, "value")
  2356  		if v2 != nil {
  2357  			var err error
  2358  			x.Value, err = NewSchema(v2, compiler.NewContext("value", v2, context))
  2359  			if err != nil {
  2360  				errors = append(errors, err)
  2361  			}
  2362  		}
  2363  	}
  2364  	return x, compiler.NewErrorGroupOrNil(errors)
  2365  }
  2366  
  2367  // NewNamedSecurityDefinitionsItem creates an object of type NamedSecurityDefinitionsItem if possible, returning an error if not.
  2368  func NewNamedSecurityDefinitionsItem(in *yaml.Node, context *compiler.Context) (*NamedSecurityDefinitionsItem, error) {
  2369  	errors := make([]error, 0)
  2370  	x := &NamedSecurityDefinitionsItem{}
  2371  	m, ok := compiler.UnpackMap(in)
  2372  	if !ok {
  2373  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2374  		errors = append(errors, compiler.NewError(context, message))
  2375  	} else {
  2376  		allowedKeys := []string{"name", "value"}
  2377  		var allowedPatterns []*regexp.Regexp
  2378  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2379  		if len(invalidKeys) > 0 {
  2380  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2381  			errors = append(errors, compiler.NewError(context, message))
  2382  		}
  2383  		// string name = 1;
  2384  		v1 := compiler.MapValueForKey(m, "name")
  2385  		if v1 != nil {
  2386  			x.Name, ok = compiler.StringForScalarNode(v1)
  2387  			if !ok {
  2388  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2389  				errors = append(errors, compiler.NewError(context, message))
  2390  			}
  2391  		}
  2392  		// SecurityDefinitionsItem value = 2;
  2393  		v2 := compiler.MapValueForKey(m, "value")
  2394  		if v2 != nil {
  2395  			var err error
  2396  			x.Value, err = NewSecurityDefinitionsItem(v2, compiler.NewContext("value", v2, context))
  2397  			if err != nil {
  2398  				errors = append(errors, err)
  2399  			}
  2400  		}
  2401  	}
  2402  	return x, compiler.NewErrorGroupOrNil(errors)
  2403  }
  2404  
  2405  // NewNamedString creates an object of type NamedString if possible, returning an error if not.
  2406  func NewNamedString(in *yaml.Node, context *compiler.Context) (*NamedString, error) {
  2407  	errors := make([]error, 0)
  2408  	x := &NamedString{}
  2409  	m, ok := compiler.UnpackMap(in)
  2410  	if !ok {
  2411  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2412  		errors = append(errors, compiler.NewError(context, message))
  2413  	} else {
  2414  		allowedKeys := []string{"name", "value"}
  2415  		var allowedPatterns []*regexp.Regexp
  2416  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2417  		if len(invalidKeys) > 0 {
  2418  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2419  			errors = append(errors, compiler.NewError(context, message))
  2420  		}
  2421  		// string name = 1;
  2422  		v1 := compiler.MapValueForKey(m, "name")
  2423  		if v1 != nil {
  2424  			x.Name, ok = compiler.StringForScalarNode(v1)
  2425  			if !ok {
  2426  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2427  				errors = append(errors, compiler.NewError(context, message))
  2428  			}
  2429  		}
  2430  		// string value = 2;
  2431  		v2 := compiler.MapValueForKey(m, "value")
  2432  		if v2 != nil {
  2433  			x.Value, ok = compiler.StringForScalarNode(v2)
  2434  			if !ok {
  2435  				message := fmt.Sprintf("has unexpected value for value: %s", compiler.Display(v2))
  2436  				errors = append(errors, compiler.NewError(context, message))
  2437  			}
  2438  		}
  2439  	}
  2440  	return x, compiler.NewErrorGroupOrNil(errors)
  2441  }
  2442  
  2443  // NewNamedStringArray creates an object of type NamedStringArray if possible, returning an error if not.
  2444  func NewNamedStringArray(in *yaml.Node, context *compiler.Context) (*NamedStringArray, error) {
  2445  	errors := make([]error, 0)
  2446  	x := &NamedStringArray{}
  2447  	m, ok := compiler.UnpackMap(in)
  2448  	if !ok {
  2449  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2450  		errors = append(errors, compiler.NewError(context, message))
  2451  	} else {
  2452  		allowedKeys := []string{"name", "value"}
  2453  		var allowedPatterns []*regexp.Regexp
  2454  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2455  		if len(invalidKeys) > 0 {
  2456  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2457  			errors = append(errors, compiler.NewError(context, message))
  2458  		}
  2459  		// string name = 1;
  2460  		v1 := compiler.MapValueForKey(m, "name")
  2461  		if v1 != nil {
  2462  			x.Name, ok = compiler.StringForScalarNode(v1)
  2463  			if !ok {
  2464  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  2465  				errors = append(errors, compiler.NewError(context, message))
  2466  			}
  2467  		}
  2468  		// StringArray value = 2;
  2469  		v2 := compiler.MapValueForKey(m, "value")
  2470  		if v2 != nil {
  2471  			var err error
  2472  			x.Value, err = NewStringArray(v2, compiler.NewContext("value", v2, context))
  2473  			if err != nil {
  2474  				errors = append(errors, err)
  2475  			}
  2476  		}
  2477  	}
  2478  	return x, compiler.NewErrorGroupOrNil(errors)
  2479  }
  2480  
  2481  // NewNonBodyParameter creates an object of type NonBodyParameter if possible, returning an error if not.
  2482  func NewNonBodyParameter(in *yaml.Node, context *compiler.Context) (*NonBodyParameter, error) {
  2483  	errors := make([]error, 0)
  2484  	x := &NonBodyParameter{}
  2485  	matched := false
  2486  	m, ok := compiler.UnpackMap(in)
  2487  	if !ok {
  2488  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2489  		errors = append(errors, compiler.NewError(context, message))
  2490  	} else {
  2491  		requiredKeys := []string{"in", "name", "type"}
  2492  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2493  		if len(missingKeys) > 0 {
  2494  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2495  			errors = append(errors, compiler.NewError(context, message))
  2496  		}
  2497  		// HeaderParameterSubSchema header_parameter_sub_schema = 1;
  2498  		{
  2499  			// errors might be ok here, they mean we just don't have the right subtype
  2500  			t, matchingError := NewHeaderParameterSubSchema(m, compiler.NewContext("headerParameterSubSchema", m, context))
  2501  			if matchingError == nil {
  2502  				x.Oneof = &NonBodyParameter_HeaderParameterSubSchema{HeaderParameterSubSchema: t}
  2503  				matched = true
  2504  			} else {
  2505  				errors = append(errors, matchingError)
  2506  			}
  2507  		}
  2508  		// FormDataParameterSubSchema form_data_parameter_sub_schema = 2;
  2509  		{
  2510  			// errors might be ok here, they mean we just don't have the right subtype
  2511  			t, matchingError := NewFormDataParameterSubSchema(m, compiler.NewContext("formDataParameterSubSchema", m, context))
  2512  			if matchingError == nil {
  2513  				x.Oneof = &NonBodyParameter_FormDataParameterSubSchema{FormDataParameterSubSchema: t}
  2514  				matched = true
  2515  			} else {
  2516  				errors = append(errors, matchingError)
  2517  			}
  2518  		}
  2519  		// QueryParameterSubSchema query_parameter_sub_schema = 3;
  2520  		{
  2521  			// errors might be ok here, they mean we just don't have the right subtype
  2522  			t, matchingError := NewQueryParameterSubSchema(m, compiler.NewContext("queryParameterSubSchema", m, context))
  2523  			if matchingError == nil {
  2524  				x.Oneof = &NonBodyParameter_QueryParameterSubSchema{QueryParameterSubSchema: t}
  2525  				matched = true
  2526  			} else {
  2527  				errors = append(errors, matchingError)
  2528  			}
  2529  		}
  2530  		// PathParameterSubSchema path_parameter_sub_schema = 4;
  2531  		{
  2532  			// errors might be ok here, they mean we just don't have the right subtype
  2533  			t, matchingError := NewPathParameterSubSchema(m, compiler.NewContext("pathParameterSubSchema", m, context))
  2534  			if matchingError == nil {
  2535  				x.Oneof = &NonBodyParameter_PathParameterSubSchema{PathParameterSubSchema: t}
  2536  				matched = true
  2537  			} else {
  2538  				errors = append(errors, matchingError)
  2539  			}
  2540  		}
  2541  	}
  2542  	if matched {
  2543  		// since the oneof matched one of its possibilities, discard any matching errors
  2544  		errors = make([]error, 0)
  2545  	} else {
  2546  		message := fmt.Sprintf("contains an invalid NonBodyParameter")
  2547  		err := compiler.NewError(context, message)
  2548  		errors = []error{err}
  2549  	}
  2550  	return x, compiler.NewErrorGroupOrNil(errors)
  2551  }
  2552  
  2553  // NewOauth2AccessCodeSecurity creates an object of type Oauth2AccessCodeSecurity if possible, returning an error if not.
  2554  func NewOauth2AccessCodeSecurity(in *yaml.Node, context *compiler.Context) (*Oauth2AccessCodeSecurity, error) {
  2555  	errors := make([]error, 0)
  2556  	x := &Oauth2AccessCodeSecurity{}
  2557  	m, ok := compiler.UnpackMap(in)
  2558  	if !ok {
  2559  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2560  		errors = append(errors, compiler.NewError(context, message))
  2561  	} else {
  2562  		requiredKeys := []string{"authorizationUrl", "flow", "tokenUrl", "type"}
  2563  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2564  		if len(missingKeys) > 0 {
  2565  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2566  			errors = append(errors, compiler.NewError(context, message))
  2567  		}
  2568  		allowedKeys := []string{"authorizationUrl", "description", "flow", "scopes", "tokenUrl", "type"}
  2569  		allowedPatterns := []*regexp.Regexp{pattern0}
  2570  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2571  		if len(invalidKeys) > 0 {
  2572  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2573  			errors = append(errors, compiler.NewError(context, message))
  2574  		}
  2575  		// string type = 1;
  2576  		v1 := compiler.MapValueForKey(m, "type")
  2577  		if v1 != nil {
  2578  			x.Type, ok = compiler.StringForScalarNode(v1)
  2579  			if !ok {
  2580  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2581  				errors = append(errors, compiler.NewError(context, message))
  2582  			}
  2583  			// check for valid enum values
  2584  			// [oauth2]
  2585  			if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
  2586  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2587  				errors = append(errors, compiler.NewError(context, message))
  2588  			}
  2589  		}
  2590  		// string flow = 2;
  2591  		v2 := compiler.MapValueForKey(m, "flow")
  2592  		if v2 != nil {
  2593  			x.Flow, ok = compiler.StringForScalarNode(v2)
  2594  			if !ok {
  2595  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2596  				errors = append(errors, compiler.NewError(context, message))
  2597  			}
  2598  			// check for valid enum values
  2599  			// [accessCode]
  2600  			if ok && !compiler.StringArrayContainsValue([]string{"accessCode"}, x.Flow) {
  2601  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2602  				errors = append(errors, compiler.NewError(context, message))
  2603  			}
  2604  		}
  2605  		// Oauth2Scopes scopes = 3;
  2606  		v3 := compiler.MapValueForKey(m, "scopes")
  2607  		if v3 != nil {
  2608  			var err error
  2609  			x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", v3, context))
  2610  			if err != nil {
  2611  				errors = append(errors, err)
  2612  			}
  2613  		}
  2614  		// string authorization_url = 4;
  2615  		v4 := compiler.MapValueForKey(m, "authorizationUrl")
  2616  		if v4 != nil {
  2617  			x.AuthorizationUrl, ok = compiler.StringForScalarNode(v4)
  2618  			if !ok {
  2619  				message := fmt.Sprintf("has unexpected value for authorizationUrl: %s", compiler.Display(v4))
  2620  				errors = append(errors, compiler.NewError(context, message))
  2621  			}
  2622  		}
  2623  		// string token_url = 5;
  2624  		v5 := compiler.MapValueForKey(m, "tokenUrl")
  2625  		if v5 != nil {
  2626  			x.TokenUrl, ok = compiler.StringForScalarNode(v5)
  2627  			if !ok {
  2628  				message := fmt.Sprintf("has unexpected value for tokenUrl: %s", compiler.Display(v5))
  2629  				errors = append(errors, compiler.NewError(context, message))
  2630  			}
  2631  		}
  2632  		// string description = 6;
  2633  		v6 := compiler.MapValueForKey(m, "description")
  2634  		if v6 != nil {
  2635  			x.Description, ok = compiler.StringForScalarNode(v6)
  2636  			if !ok {
  2637  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v6))
  2638  				errors = append(errors, compiler.NewError(context, message))
  2639  			}
  2640  		}
  2641  		// repeated NamedAny vendor_extension = 7;
  2642  		// MAP: Any ^x-
  2643  		x.VendorExtension = make([]*NamedAny, 0)
  2644  		for i := 0; i < len(m.Content); i += 2 {
  2645  			k, ok := compiler.StringForScalarNode(m.Content[i])
  2646  			if ok {
  2647  				v := m.Content[i+1]
  2648  				if strings.HasPrefix(k, "x-") {
  2649  					pair := &NamedAny{}
  2650  					pair.Name = k
  2651  					result := &Any{}
  2652  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  2653  					if handled {
  2654  						if err != nil {
  2655  							errors = append(errors, err)
  2656  						} else {
  2657  							bytes := compiler.Marshal(v)
  2658  							result.Yaml = string(bytes)
  2659  							result.Value = resultFromExt
  2660  							pair.Value = result
  2661  						}
  2662  					} else {
  2663  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  2664  						if err != nil {
  2665  							errors = append(errors, err)
  2666  						}
  2667  					}
  2668  					x.VendorExtension = append(x.VendorExtension, pair)
  2669  				}
  2670  			}
  2671  		}
  2672  	}
  2673  	return x, compiler.NewErrorGroupOrNil(errors)
  2674  }
  2675  
  2676  // NewOauth2ApplicationSecurity creates an object of type Oauth2ApplicationSecurity if possible, returning an error if not.
  2677  func NewOauth2ApplicationSecurity(in *yaml.Node, context *compiler.Context) (*Oauth2ApplicationSecurity, error) {
  2678  	errors := make([]error, 0)
  2679  	x := &Oauth2ApplicationSecurity{}
  2680  	m, ok := compiler.UnpackMap(in)
  2681  	if !ok {
  2682  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2683  		errors = append(errors, compiler.NewError(context, message))
  2684  	} else {
  2685  		requiredKeys := []string{"flow", "tokenUrl", "type"}
  2686  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2687  		if len(missingKeys) > 0 {
  2688  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2689  			errors = append(errors, compiler.NewError(context, message))
  2690  		}
  2691  		allowedKeys := []string{"description", "flow", "scopes", "tokenUrl", "type"}
  2692  		allowedPatterns := []*regexp.Regexp{pattern0}
  2693  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2694  		if len(invalidKeys) > 0 {
  2695  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2696  			errors = append(errors, compiler.NewError(context, message))
  2697  		}
  2698  		// string type = 1;
  2699  		v1 := compiler.MapValueForKey(m, "type")
  2700  		if v1 != nil {
  2701  			x.Type, ok = compiler.StringForScalarNode(v1)
  2702  			if !ok {
  2703  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2704  				errors = append(errors, compiler.NewError(context, message))
  2705  			}
  2706  			// check for valid enum values
  2707  			// [oauth2]
  2708  			if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
  2709  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2710  				errors = append(errors, compiler.NewError(context, message))
  2711  			}
  2712  		}
  2713  		// string flow = 2;
  2714  		v2 := compiler.MapValueForKey(m, "flow")
  2715  		if v2 != nil {
  2716  			x.Flow, ok = compiler.StringForScalarNode(v2)
  2717  			if !ok {
  2718  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2719  				errors = append(errors, compiler.NewError(context, message))
  2720  			}
  2721  			// check for valid enum values
  2722  			// [application]
  2723  			if ok && !compiler.StringArrayContainsValue([]string{"application"}, x.Flow) {
  2724  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2725  				errors = append(errors, compiler.NewError(context, message))
  2726  			}
  2727  		}
  2728  		// Oauth2Scopes scopes = 3;
  2729  		v3 := compiler.MapValueForKey(m, "scopes")
  2730  		if v3 != nil {
  2731  			var err error
  2732  			x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", v3, context))
  2733  			if err != nil {
  2734  				errors = append(errors, err)
  2735  			}
  2736  		}
  2737  		// string token_url = 4;
  2738  		v4 := compiler.MapValueForKey(m, "tokenUrl")
  2739  		if v4 != nil {
  2740  			x.TokenUrl, ok = compiler.StringForScalarNode(v4)
  2741  			if !ok {
  2742  				message := fmt.Sprintf("has unexpected value for tokenUrl: %s", compiler.Display(v4))
  2743  				errors = append(errors, compiler.NewError(context, message))
  2744  			}
  2745  		}
  2746  		// string description = 5;
  2747  		v5 := compiler.MapValueForKey(m, "description")
  2748  		if v5 != nil {
  2749  			x.Description, ok = compiler.StringForScalarNode(v5)
  2750  			if !ok {
  2751  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v5))
  2752  				errors = append(errors, compiler.NewError(context, message))
  2753  			}
  2754  		}
  2755  		// repeated NamedAny vendor_extension = 6;
  2756  		// MAP: Any ^x-
  2757  		x.VendorExtension = make([]*NamedAny, 0)
  2758  		for i := 0; i < len(m.Content); i += 2 {
  2759  			k, ok := compiler.StringForScalarNode(m.Content[i])
  2760  			if ok {
  2761  				v := m.Content[i+1]
  2762  				if strings.HasPrefix(k, "x-") {
  2763  					pair := &NamedAny{}
  2764  					pair.Name = k
  2765  					result := &Any{}
  2766  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  2767  					if handled {
  2768  						if err != nil {
  2769  							errors = append(errors, err)
  2770  						} else {
  2771  							bytes := compiler.Marshal(v)
  2772  							result.Yaml = string(bytes)
  2773  							result.Value = resultFromExt
  2774  							pair.Value = result
  2775  						}
  2776  					} else {
  2777  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  2778  						if err != nil {
  2779  							errors = append(errors, err)
  2780  						}
  2781  					}
  2782  					x.VendorExtension = append(x.VendorExtension, pair)
  2783  				}
  2784  			}
  2785  		}
  2786  	}
  2787  	return x, compiler.NewErrorGroupOrNil(errors)
  2788  }
  2789  
  2790  // NewOauth2ImplicitSecurity creates an object of type Oauth2ImplicitSecurity if possible, returning an error if not.
  2791  func NewOauth2ImplicitSecurity(in *yaml.Node, context *compiler.Context) (*Oauth2ImplicitSecurity, error) {
  2792  	errors := make([]error, 0)
  2793  	x := &Oauth2ImplicitSecurity{}
  2794  	m, ok := compiler.UnpackMap(in)
  2795  	if !ok {
  2796  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2797  		errors = append(errors, compiler.NewError(context, message))
  2798  	} else {
  2799  		requiredKeys := []string{"authorizationUrl", "flow", "type"}
  2800  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2801  		if len(missingKeys) > 0 {
  2802  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2803  			errors = append(errors, compiler.NewError(context, message))
  2804  		}
  2805  		allowedKeys := []string{"authorizationUrl", "description", "flow", "scopes", "type"}
  2806  		allowedPatterns := []*regexp.Regexp{pattern0}
  2807  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2808  		if len(invalidKeys) > 0 {
  2809  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2810  			errors = append(errors, compiler.NewError(context, message))
  2811  		}
  2812  		// string type = 1;
  2813  		v1 := compiler.MapValueForKey(m, "type")
  2814  		if v1 != nil {
  2815  			x.Type, ok = compiler.StringForScalarNode(v1)
  2816  			if !ok {
  2817  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2818  				errors = append(errors, compiler.NewError(context, message))
  2819  			}
  2820  			// check for valid enum values
  2821  			// [oauth2]
  2822  			if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
  2823  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2824  				errors = append(errors, compiler.NewError(context, message))
  2825  			}
  2826  		}
  2827  		// string flow = 2;
  2828  		v2 := compiler.MapValueForKey(m, "flow")
  2829  		if v2 != nil {
  2830  			x.Flow, ok = compiler.StringForScalarNode(v2)
  2831  			if !ok {
  2832  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2833  				errors = append(errors, compiler.NewError(context, message))
  2834  			}
  2835  			// check for valid enum values
  2836  			// [implicit]
  2837  			if ok && !compiler.StringArrayContainsValue([]string{"implicit"}, x.Flow) {
  2838  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2839  				errors = append(errors, compiler.NewError(context, message))
  2840  			}
  2841  		}
  2842  		// Oauth2Scopes scopes = 3;
  2843  		v3 := compiler.MapValueForKey(m, "scopes")
  2844  		if v3 != nil {
  2845  			var err error
  2846  			x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", v3, context))
  2847  			if err != nil {
  2848  				errors = append(errors, err)
  2849  			}
  2850  		}
  2851  		// string authorization_url = 4;
  2852  		v4 := compiler.MapValueForKey(m, "authorizationUrl")
  2853  		if v4 != nil {
  2854  			x.AuthorizationUrl, ok = compiler.StringForScalarNode(v4)
  2855  			if !ok {
  2856  				message := fmt.Sprintf("has unexpected value for authorizationUrl: %s", compiler.Display(v4))
  2857  				errors = append(errors, compiler.NewError(context, message))
  2858  			}
  2859  		}
  2860  		// string description = 5;
  2861  		v5 := compiler.MapValueForKey(m, "description")
  2862  		if v5 != nil {
  2863  			x.Description, ok = compiler.StringForScalarNode(v5)
  2864  			if !ok {
  2865  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v5))
  2866  				errors = append(errors, compiler.NewError(context, message))
  2867  			}
  2868  		}
  2869  		// repeated NamedAny vendor_extension = 6;
  2870  		// MAP: Any ^x-
  2871  		x.VendorExtension = make([]*NamedAny, 0)
  2872  		for i := 0; i < len(m.Content); i += 2 {
  2873  			k, ok := compiler.StringForScalarNode(m.Content[i])
  2874  			if ok {
  2875  				v := m.Content[i+1]
  2876  				if strings.HasPrefix(k, "x-") {
  2877  					pair := &NamedAny{}
  2878  					pair.Name = k
  2879  					result := &Any{}
  2880  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  2881  					if handled {
  2882  						if err != nil {
  2883  							errors = append(errors, err)
  2884  						} else {
  2885  							bytes := compiler.Marshal(v)
  2886  							result.Yaml = string(bytes)
  2887  							result.Value = resultFromExt
  2888  							pair.Value = result
  2889  						}
  2890  					} else {
  2891  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  2892  						if err != nil {
  2893  							errors = append(errors, err)
  2894  						}
  2895  					}
  2896  					x.VendorExtension = append(x.VendorExtension, pair)
  2897  				}
  2898  			}
  2899  		}
  2900  	}
  2901  	return x, compiler.NewErrorGroupOrNil(errors)
  2902  }
  2903  
  2904  // NewOauth2PasswordSecurity creates an object of type Oauth2PasswordSecurity if possible, returning an error if not.
  2905  func NewOauth2PasswordSecurity(in *yaml.Node, context *compiler.Context) (*Oauth2PasswordSecurity, error) {
  2906  	errors := make([]error, 0)
  2907  	x := &Oauth2PasswordSecurity{}
  2908  	m, ok := compiler.UnpackMap(in)
  2909  	if !ok {
  2910  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  2911  		errors = append(errors, compiler.NewError(context, message))
  2912  	} else {
  2913  		requiredKeys := []string{"flow", "tokenUrl", "type"}
  2914  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  2915  		if len(missingKeys) > 0 {
  2916  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  2917  			errors = append(errors, compiler.NewError(context, message))
  2918  		}
  2919  		allowedKeys := []string{"description", "flow", "scopes", "tokenUrl", "type"}
  2920  		allowedPatterns := []*regexp.Regexp{pattern0}
  2921  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  2922  		if len(invalidKeys) > 0 {
  2923  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  2924  			errors = append(errors, compiler.NewError(context, message))
  2925  		}
  2926  		// string type = 1;
  2927  		v1 := compiler.MapValueForKey(m, "type")
  2928  		if v1 != nil {
  2929  			x.Type, ok = compiler.StringForScalarNode(v1)
  2930  			if !ok {
  2931  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2932  				errors = append(errors, compiler.NewError(context, message))
  2933  			}
  2934  			// check for valid enum values
  2935  			// [oauth2]
  2936  			if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
  2937  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  2938  				errors = append(errors, compiler.NewError(context, message))
  2939  			}
  2940  		}
  2941  		// string flow = 2;
  2942  		v2 := compiler.MapValueForKey(m, "flow")
  2943  		if v2 != nil {
  2944  			x.Flow, ok = compiler.StringForScalarNode(v2)
  2945  			if !ok {
  2946  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2947  				errors = append(errors, compiler.NewError(context, message))
  2948  			}
  2949  			// check for valid enum values
  2950  			// [password]
  2951  			if ok && !compiler.StringArrayContainsValue([]string{"password"}, x.Flow) {
  2952  				message := fmt.Sprintf("has unexpected value for flow: %s", compiler.Display(v2))
  2953  				errors = append(errors, compiler.NewError(context, message))
  2954  			}
  2955  		}
  2956  		// Oauth2Scopes scopes = 3;
  2957  		v3 := compiler.MapValueForKey(m, "scopes")
  2958  		if v3 != nil {
  2959  			var err error
  2960  			x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", v3, context))
  2961  			if err != nil {
  2962  				errors = append(errors, err)
  2963  			}
  2964  		}
  2965  		// string token_url = 4;
  2966  		v4 := compiler.MapValueForKey(m, "tokenUrl")
  2967  		if v4 != nil {
  2968  			x.TokenUrl, ok = compiler.StringForScalarNode(v4)
  2969  			if !ok {
  2970  				message := fmt.Sprintf("has unexpected value for tokenUrl: %s", compiler.Display(v4))
  2971  				errors = append(errors, compiler.NewError(context, message))
  2972  			}
  2973  		}
  2974  		// string description = 5;
  2975  		v5 := compiler.MapValueForKey(m, "description")
  2976  		if v5 != nil {
  2977  			x.Description, ok = compiler.StringForScalarNode(v5)
  2978  			if !ok {
  2979  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v5))
  2980  				errors = append(errors, compiler.NewError(context, message))
  2981  			}
  2982  		}
  2983  		// repeated NamedAny vendor_extension = 6;
  2984  		// MAP: Any ^x-
  2985  		x.VendorExtension = make([]*NamedAny, 0)
  2986  		for i := 0; i < len(m.Content); i += 2 {
  2987  			k, ok := compiler.StringForScalarNode(m.Content[i])
  2988  			if ok {
  2989  				v := m.Content[i+1]
  2990  				if strings.HasPrefix(k, "x-") {
  2991  					pair := &NamedAny{}
  2992  					pair.Name = k
  2993  					result := &Any{}
  2994  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  2995  					if handled {
  2996  						if err != nil {
  2997  							errors = append(errors, err)
  2998  						} else {
  2999  							bytes := compiler.Marshal(v)
  3000  							result.Yaml = string(bytes)
  3001  							result.Value = resultFromExt
  3002  							pair.Value = result
  3003  						}
  3004  					} else {
  3005  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  3006  						if err != nil {
  3007  							errors = append(errors, err)
  3008  						}
  3009  					}
  3010  					x.VendorExtension = append(x.VendorExtension, pair)
  3011  				}
  3012  			}
  3013  		}
  3014  	}
  3015  	return x, compiler.NewErrorGroupOrNil(errors)
  3016  }
  3017  
  3018  // NewOauth2Scopes creates an object of type Oauth2Scopes if possible, returning an error if not.
  3019  func NewOauth2Scopes(in *yaml.Node, context *compiler.Context) (*Oauth2Scopes, error) {
  3020  	errors := make([]error, 0)
  3021  	x := &Oauth2Scopes{}
  3022  	m, ok := compiler.UnpackMap(in)
  3023  	if !ok {
  3024  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3025  		errors = append(errors, compiler.NewError(context, message))
  3026  	} else {
  3027  		// repeated NamedString additional_properties = 1;
  3028  		// MAP: string
  3029  		x.AdditionalProperties = make([]*NamedString, 0)
  3030  		for i := 0; i < len(m.Content); i += 2 {
  3031  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3032  			if ok {
  3033  				v := m.Content[i+1]
  3034  				pair := &NamedString{}
  3035  				pair.Name = k
  3036  				pair.Value, _ = compiler.StringForScalarNode(v)
  3037  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  3038  			}
  3039  		}
  3040  	}
  3041  	return x, compiler.NewErrorGroupOrNil(errors)
  3042  }
  3043  
  3044  // NewOperation creates an object of type Operation if possible, returning an error if not.
  3045  func NewOperation(in *yaml.Node, context *compiler.Context) (*Operation, error) {
  3046  	errors := make([]error, 0)
  3047  	x := &Operation{}
  3048  	m, ok := compiler.UnpackMap(in)
  3049  	if !ok {
  3050  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3051  		errors = append(errors, compiler.NewError(context, message))
  3052  	} else {
  3053  		requiredKeys := []string{"responses"}
  3054  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  3055  		if len(missingKeys) > 0 {
  3056  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  3057  			errors = append(errors, compiler.NewError(context, message))
  3058  		}
  3059  		allowedKeys := []string{"consumes", "deprecated", "description", "externalDocs", "operationId", "parameters", "produces", "responses", "schemes", "security", "summary", "tags"}
  3060  		allowedPatterns := []*regexp.Regexp{pattern0}
  3061  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  3062  		if len(invalidKeys) > 0 {
  3063  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  3064  			errors = append(errors, compiler.NewError(context, message))
  3065  		}
  3066  		// repeated string tags = 1;
  3067  		v1 := compiler.MapValueForKey(m, "tags")
  3068  		if v1 != nil {
  3069  			v, ok := compiler.SequenceNodeForNode(v1)
  3070  			if ok {
  3071  				x.Tags = compiler.StringArrayForSequenceNode(v)
  3072  			} else {
  3073  				message := fmt.Sprintf("has unexpected value for tags: %s", compiler.Display(v1))
  3074  				errors = append(errors, compiler.NewError(context, message))
  3075  			}
  3076  		}
  3077  		// string summary = 2;
  3078  		v2 := compiler.MapValueForKey(m, "summary")
  3079  		if v2 != nil {
  3080  			x.Summary, ok = compiler.StringForScalarNode(v2)
  3081  			if !ok {
  3082  				message := fmt.Sprintf("has unexpected value for summary: %s", compiler.Display(v2))
  3083  				errors = append(errors, compiler.NewError(context, message))
  3084  			}
  3085  		}
  3086  		// string description = 3;
  3087  		v3 := compiler.MapValueForKey(m, "description")
  3088  		if v3 != nil {
  3089  			x.Description, ok = compiler.StringForScalarNode(v3)
  3090  			if !ok {
  3091  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  3092  				errors = append(errors, compiler.NewError(context, message))
  3093  			}
  3094  		}
  3095  		// ExternalDocs external_docs = 4;
  3096  		v4 := compiler.MapValueForKey(m, "externalDocs")
  3097  		if v4 != nil {
  3098  			var err error
  3099  			x.ExternalDocs, err = NewExternalDocs(v4, compiler.NewContext("externalDocs", v4, context))
  3100  			if err != nil {
  3101  				errors = append(errors, err)
  3102  			}
  3103  		}
  3104  		// string operation_id = 5;
  3105  		v5 := compiler.MapValueForKey(m, "operationId")
  3106  		if v5 != nil {
  3107  			x.OperationId, ok = compiler.StringForScalarNode(v5)
  3108  			if !ok {
  3109  				message := fmt.Sprintf("has unexpected value for operationId: %s", compiler.Display(v5))
  3110  				errors = append(errors, compiler.NewError(context, message))
  3111  			}
  3112  		}
  3113  		// repeated string produces = 6;
  3114  		v6 := compiler.MapValueForKey(m, "produces")
  3115  		if v6 != nil {
  3116  			v, ok := compiler.SequenceNodeForNode(v6)
  3117  			if ok {
  3118  				x.Produces = compiler.StringArrayForSequenceNode(v)
  3119  			} else {
  3120  				message := fmt.Sprintf("has unexpected value for produces: %s", compiler.Display(v6))
  3121  				errors = append(errors, compiler.NewError(context, message))
  3122  			}
  3123  		}
  3124  		// repeated string consumes = 7;
  3125  		v7 := compiler.MapValueForKey(m, "consumes")
  3126  		if v7 != nil {
  3127  			v, ok := compiler.SequenceNodeForNode(v7)
  3128  			if ok {
  3129  				x.Consumes = compiler.StringArrayForSequenceNode(v)
  3130  			} else {
  3131  				message := fmt.Sprintf("has unexpected value for consumes: %s", compiler.Display(v7))
  3132  				errors = append(errors, compiler.NewError(context, message))
  3133  			}
  3134  		}
  3135  		// repeated ParametersItem parameters = 8;
  3136  		v8 := compiler.MapValueForKey(m, "parameters")
  3137  		if v8 != nil {
  3138  			// repeated ParametersItem
  3139  			x.Parameters = make([]*ParametersItem, 0)
  3140  			a, ok := compiler.SequenceNodeForNode(v8)
  3141  			if ok {
  3142  				for _, item := range a.Content {
  3143  					y, err := NewParametersItem(item, compiler.NewContext("parameters", item, context))
  3144  					if err != nil {
  3145  						errors = append(errors, err)
  3146  					}
  3147  					x.Parameters = append(x.Parameters, y)
  3148  				}
  3149  			}
  3150  		}
  3151  		// Responses responses = 9;
  3152  		v9 := compiler.MapValueForKey(m, "responses")
  3153  		if v9 != nil {
  3154  			var err error
  3155  			x.Responses, err = NewResponses(v9, compiler.NewContext("responses", v9, context))
  3156  			if err != nil {
  3157  				errors = append(errors, err)
  3158  			}
  3159  		}
  3160  		// repeated string schemes = 10;
  3161  		v10 := compiler.MapValueForKey(m, "schemes")
  3162  		if v10 != nil {
  3163  			v, ok := compiler.SequenceNodeForNode(v10)
  3164  			if ok {
  3165  				x.Schemes = compiler.StringArrayForSequenceNode(v)
  3166  			} else {
  3167  				message := fmt.Sprintf("has unexpected value for schemes: %s", compiler.Display(v10))
  3168  				errors = append(errors, compiler.NewError(context, message))
  3169  			}
  3170  			// check for valid enum values
  3171  			// [http https ws wss]
  3172  			if ok && !compiler.StringArrayContainsValues([]string{"http", "https", "ws", "wss"}, x.Schemes) {
  3173  				message := fmt.Sprintf("has unexpected value for schemes: %s", compiler.Display(v10))
  3174  				errors = append(errors, compiler.NewError(context, message))
  3175  			}
  3176  		}
  3177  		// bool deprecated = 11;
  3178  		v11 := compiler.MapValueForKey(m, "deprecated")
  3179  		if v11 != nil {
  3180  			x.Deprecated, ok = compiler.BoolForScalarNode(v11)
  3181  			if !ok {
  3182  				message := fmt.Sprintf("has unexpected value for deprecated: %s", compiler.Display(v11))
  3183  				errors = append(errors, compiler.NewError(context, message))
  3184  			}
  3185  		}
  3186  		// repeated SecurityRequirement security = 12;
  3187  		v12 := compiler.MapValueForKey(m, "security")
  3188  		if v12 != nil {
  3189  			// repeated SecurityRequirement
  3190  			x.Security = make([]*SecurityRequirement, 0)
  3191  			a, ok := compiler.SequenceNodeForNode(v12)
  3192  			if ok {
  3193  				for _, item := range a.Content {
  3194  					y, err := NewSecurityRequirement(item, compiler.NewContext("security", item, context))
  3195  					if err != nil {
  3196  						errors = append(errors, err)
  3197  					}
  3198  					x.Security = append(x.Security, y)
  3199  				}
  3200  			}
  3201  		}
  3202  		// repeated NamedAny vendor_extension = 13;
  3203  		// MAP: Any ^x-
  3204  		x.VendorExtension = make([]*NamedAny, 0)
  3205  		for i := 0; i < len(m.Content); i += 2 {
  3206  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3207  			if ok {
  3208  				v := m.Content[i+1]
  3209  				if strings.HasPrefix(k, "x-") {
  3210  					pair := &NamedAny{}
  3211  					pair.Name = k
  3212  					result := &Any{}
  3213  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  3214  					if handled {
  3215  						if err != nil {
  3216  							errors = append(errors, err)
  3217  						} else {
  3218  							bytes := compiler.Marshal(v)
  3219  							result.Yaml = string(bytes)
  3220  							result.Value = resultFromExt
  3221  							pair.Value = result
  3222  						}
  3223  					} else {
  3224  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  3225  						if err != nil {
  3226  							errors = append(errors, err)
  3227  						}
  3228  					}
  3229  					x.VendorExtension = append(x.VendorExtension, pair)
  3230  				}
  3231  			}
  3232  		}
  3233  	}
  3234  	return x, compiler.NewErrorGroupOrNil(errors)
  3235  }
  3236  
  3237  // NewParameter creates an object of type Parameter if possible, returning an error if not.
  3238  func NewParameter(in *yaml.Node, context *compiler.Context) (*Parameter, error) {
  3239  	errors := make([]error, 0)
  3240  	x := &Parameter{}
  3241  	matched := false
  3242  	// BodyParameter body_parameter = 1;
  3243  	{
  3244  		m, ok := compiler.UnpackMap(in)
  3245  		if ok {
  3246  			// errors might be ok here, they mean we just don't have the right subtype
  3247  			t, matchingError := NewBodyParameter(m, compiler.NewContext("bodyParameter", m, context))
  3248  			if matchingError == nil {
  3249  				x.Oneof = &Parameter_BodyParameter{BodyParameter: t}
  3250  				matched = true
  3251  			} else {
  3252  				errors = append(errors, matchingError)
  3253  			}
  3254  		}
  3255  	}
  3256  	// NonBodyParameter non_body_parameter = 2;
  3257  	{
  3258  		m, ok := compiler.UnpackMap(in)
  3259  		if ok {
  3260  			// errors might be ok here, they mean we just don't have the right subtype
  3261  			t, matchingError := NewNonBodyParameter(m, compiler.NewContext("nonBodyParameter", m, context))
  3262  			if matchingError == nil {
  3263  				x.Oneof = &Parameter_NonBodyParameter{NonBodyParameter: t}
  3264  				matched = true
  3265  			} else {
  3266  				errors = append(errors, matchingError)
  3267  			}
  3268  		}
  3269  	}
  3270  	if matched {
  3271  		// since the oneof matched one of its possibilities, discard any matching errors
  3272  		errors = make([]error, 0)
  3273  	} else {
  3274  		message := fmt.Sprintf("contains an invalid Parameter")
  3275  		err := compiler.NewError(context, message)
  3276  		errors = []error{err}
  3277  	}
  3278  	return x, compiler.NewErrorGroupOrNil(errors)
  3279  }
  3280  
  3281  // NewParameterDefinitions creates an object of type ParameterDefinitions if possible, returning an error if not.
  3282  func NewParameterDefinitions(in *yaml.Node, context *compiler.Context) (*ParameterDefinitions, error) {
  3283  	errors := make([]error, 0)
  3284  	x := &ParameterDefinitions{}
  3285  	m, ok := compiler.UnpackMap(in)
  3286  	if !ok {
  3287  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3288  		errors = append(errors, compiler.NewError(context, message))
  3289  	} else {
  3290  		// repeated NamedParameter additional_properties = 1;
  3291  		// MAP: Parameter
  3292  		x.AdditionalProperties = make([]*NamedParameter, 0)
  3293  		for i := 0; i < len(m.Content); i += 2 {
  3294  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3295  			if ok {
  3296  				v := m.Content[i+1]
  3297  				pair := &NamedParameter{}
  3298  				pair.Name = k
  3299  				var err error
  3300  				pair.Value, err = NewParameter(v, compiler.NewContext(k, v, context))
  3301  				if err != nil {
  3302  					errors = append(errors, err)
  3303  				}
  3304  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  3305  			}
  3306  		}
  3307  	}
  3308  	return x, compiler.NewErrorGroupOrNil(errors)
  3309  }
  3310  
  3311  // NewParametersItem creates an object of type ParametersItem if possible, returning an error if not.
  3312  func NewParametersItem(in *yaml.Node, context *compiler.Context) (*ParametersItem, error) {
  3313  	errors := make([]error, 0)
  3314  	x := &ParametersItem{}
  3315  	matched := false
  3316  	// Parameter parameter = 1;
  3317  	{
  3318  		m, ok := compiler.UnpackMap(in)
  3319  		if ok {
  3320  			// errors might be ok here, they mean we just don't have the right subtype
  3321  			t, matchingError := NewParameter(m, compiler.NewContext("parameter", m, context))
  3322  			if matchingError == nil {
  3323  				x.Oneof = &ParametersItem_Parameter{Parameter: t}
  3324  				matched = true
  3325  			} else {
  3326  				errors = append(errors, matchingError)
  3327  			}
  3328  		}
  3329  	}
  3330  	// JsonReference json_reference = 2;
  3331  	{
  3332  		m, ok := compiler.UnpackMap(in)
  3333  		if ok {
  3334  			// errors might be ok here, they mean we just don't have the right subtype
  3335  			t, matchingError := NewJsonReference(m, compiler.NewContext("jsonReference", m, context))
  3336  			if matchingError == nil {
  3337  				x.Oneof = &ParametersItem_JsonReference{JsonReference: t}
  3338  				matched = true
  3339  			} else {
  3340  				errors = append(errors, matchingError)
  3341  			}
  3342  		}
  3343  	}
  3344  	if matched {
  3345  		// since the oneof matched one of its possibilities, discard any matching errors
  3346  		errors = make([]error, 0)
  3347  	} else {
  3348  		message := fmt.Sprintf("contains an invalid ParametersItem")
  3349  		err := compiler.NewError(context, message)
  3350  		errors = []error{err}
  3351  	}
  3352  	return x, compiler.NewErrorGroupOrNil(errors)
  3353  }
  3354  
  3355  // NewPathItem creates an object of type PathItem if possible, returning an error if not.
  3356  func NewPathItem(in *yaml.Node, context *compiler.Context) (*PathItem, error) {
  3357  	errors := make([]error, 0)
  3358  	x := &PathItem{}
  3359  	m, ok := compiler.UnpackMap(in)
  3360  	if !ok {
  3361  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3362  		errors = append(errors, compiler.NewError(context, message))
  3363  	} else {
  3364  		allowedKeys := []string{"$ref", "delete", "get", "head", "options", "parameters", "patch", "post", "put"}
  3365  		allowedPatterns := []*regexp.Regexp{pattern0}
  3366  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  3367  		if len(invalidKeys) > 0 {
  3368  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  3369  			errors = append(errors, compiler.NewError(context, message))
  3370  		}
  3371  		// string _ref = 1;
  3372  		v1 := compiler.MapValueForKey(m, "$ref")
  3373  		if v1 != nil {
  3374  			x.XRef, ok = compiler.StringForScalarNode(v1)
  3375  			if !ok {
  3376  				message := fmt.Sprintf("has unexpected value for $ref: %s", compiler.Display(v1))
  3377  				errors = append(errors, compiler.NewError(context, message))
  3378  			}
  3379  		}
  3380  		// Operation get = 2;
  3381  		v2 := compiler.MapValueForKey(m, "get")
  3382  		if v2 != nil {
  3383  			var err error
  3384  			x.Get, err = NewOperation(v2, compiler.NewContext("get", v2, context))
  3385  			if err != nil {
  3386  				errors = append(errors, err)
  3387  			}
  3388  		}
  3389  		// Operation put = 3;
  3390  		v3 := compiler.MapValueForKey(m, "put")
  3391  		if v3 != nil {
  3392  			var err error
  3393  			x.Put, err = NewOperation(v3, compiler.NewContext("put", v3, context))
  3394  			if err != nil {
  3395  				errors = append(errors, err)
  3396  			}
  3397  		}
  3398  		// Operation post = 4;
  3399  		v4 := compiler.MapValueForKey(m, "post")
  3400  		if v4 != nil {
  3401  			var err error
  3402  			x.Post, err = NewOperation(v4, compiler.NewContext("post", v4, context))
  3403  			if err != nil {
  3404  				errors = append(errors, err)
  3405  			}
  3406  		}
  3407  		// Operation delete = 5;
  3408  		v5 := compiler.MapValueForKey(m, "delete")
  3409  		if v5 != nil {
  3410  			var err error
  3411  			x.Delete, err = NewOperation(v5, compiler.NewContext("delete", v5, context))
  3412  			if err != nil {
  3413  				errors = append(errors, err)
  3414  			}
  3415  		}
  3416  		// Operation options = 6;
  3417  		v6 := compiler.MapValueForKey(m, "options")
  3418  		if v6 != nil {
  3419  			var err error
  3420  			x.Options, err = NewOperation(v6, compiler.NewContext("options", v6, context))
  3421  			if err != nil {
  3422  				errors = append(errors, err)
  3423  			}
  3424  		}
  3425  		// Operation head = 7;
  3426  		v7 := compiler.MapValueForKey(m, "head")
  3427  		if v7 != nil {
  3428  			var err error
  3429  			x.Head, err = NewOperation(v7, compiler.NewContext("head", v7, context))
  3430  			if err != nil {
  3431  				errors = append(errors, err)
  3432  			}
  3433  		}
  3434  		// Operation patch = 8;
  3435  		v8 := compiler.MapValueForKey(m, "patch")
  3436  		if v8 != nil {
  3437  			var err error
  3438  			x.Patch, err = NewOperation(v8, compiler.NewContext("patch", v8, context))
  3439  			if err != nil {
  3440  				errors = append(errors, err)
  3441  			}
  3442  		}
  3443  		// repeated ParametersItem parameters = 9;
  3444  		v9 := compiler.MapValueForKey(m, "parameters")
  3445  		if v9 != nil {
  3446  			// repeated ParametersItem
  3447  			x.Parameters = make([]*ParametersItem, 0)
  3448  			a, ok := compiler.SequenceNodeForNode(v9)
  3449  			if ok {
  3450  				for _, item := range a.Content {
  3451  					y, err := NewParametersItem(item, compiler.NewContext("parameters", item, context))
  3452  					if err != nil {
  3453  						errors = append(errors, err)
  3454  					}
  3455  					x.Parameters = append(x.Parameters, y)
  3456  				}
  3457  			}
  3458  		}
  3459  		// repeated NamedAny vendor_extension = 10;
  3460  		// MAP: Any ^x-
  3461  		x.VendorExtension = make([]*NamedAny, 0)
  3462  		for i := 0; i < len(m.Content); i += 2 {
  3463  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3464  			if ok {
  3465  				v := m.Content[i+1]
  3466  				if strings.HasPrefix(k, "x-") {
  3467  					pair := &NamedAny{}
  3468  					pair.Name = k
  3469  					result := &Any{}
  3470  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  3471  					if handled {
  3472  						if err != nil {
  3473  							errors = append(errors, err)
  3474  						} else {
  3475  							bytes := compiler.Marshal(v)
  3476  							result.Yaml = string(bytes)
  3477  							result.Value = resultFromExt
  3478  							pair.Value = result
  3479  						}
  3480  					} else {
  3481  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  3482  						if err != nil {
  3483  							errors = append(errors, err)
  3484  						}
  3485  					}
  3486  					x.VendorExtension = append(x.VendorExtension, pair)
  3487  				}
  3488  			}
  3489  		}
  3490  	}
  3491  	return x, compiler.NewErrorGroupOrNil(errors)
  3492  }
  3493  
  3494  // NewPathParameterSubSchema creates an object of type PathParameterSubSchema if possible, returning an error if not.
  3495  func NewPathParameterSubSchema(in *yaml.Node, context *compiler.Context) (*PathParameterSubSchema, error) {
  3496  	errors := make([]error, 0)
  3497  	x := &PathParameterSubSchema{}
  3498  	m, ok := compiler.UnpackMap(in)
  3499  	if !ok {
  3500  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3501  		errors = append(errors, compiler.NewError(context, message))
  3502  	} else {
  3503  		requiredKeys := []string{"required"}
  3504  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  3505  		if len(missingKeys) > 0 {
  3506  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  3507  			errors = append(errors, compiler.NewError(context, message))
  3508  		}
  3509  		allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
  3510  		allowedPatterns := []*regexp.Regexp{pattern0}
  3511  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  3512  		if len(invalidKeys) > 0 {
  3513  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  3514  			errors = append(errors, compiler.NewError(context, message))
  3515  		}
  3516  		// bool required = 1;
  3517  		v1 := compiler.MapValueForKey(m, "required")
  3518  		if v1 != nil {
  3519  			x.Required, ok = compiler.BoolForScalarNode(v1)
  3520  			if !ok {
  3521  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v1))
  3522  				errors = append(errors, compiler.NewError(context, message))
  3523  			}
  3524  		}
  3525  		// string in = 2;
  3526  		v2 := compiler.MapValueForKey(m, "in")
  3527  		if v2 != nil {
  3528  			x.In, ok = compiler.StringForScalarNode(v2)
  3529  			if !ok {
  3530  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  3531  				errors = append(errors, compiler.NewError(context, message))
  3532  			}
  3533  			// check for valid enum values
  3534  			// [path]
  3535  			if ok && !compiler.StringArrayContainsValue([]string{"path"}, x.In) {
  3536  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  3537  				errors = append(errors, compiler.NewError(context, message))
  3538  			}
  3539  		}
  3540  		// string description = 3;
  3541  		v3 := compiler.MapValueForKey(m, "description")
  3542  		if v3 != nil {
  3543  			x.Description, ok = compiler.StringForScalarNode(v3)
  3544  			if !ok {
  3545  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  3546  				errors = append(errors, compiler.NewError(context, message))
  3547  			}
  3548  		}
  3549  		// string name = 4;
  3550  		v4 := compiler.MapValueForKey(m, "name")
  3551  		if v4 != nil {
  3552  			x.Name, ok = compiler.StringForScalarNode(v4)
  3553  			if !ok {
  3554  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v4))
  3555  				errors = append(errors, compiler.NewError(context, message))
  3556  			}
  3557  		}
  3558  		// string type = 5;
  3559  		v5 := compiler.MapValueForKey(m, "type")
  3560  		if v5 != nil {
  3561  			x.Type, ok = compiler.StringForScalarNode(v5)
  3562  			if !ok {
  3563  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v5))
  3564  				errors = append(errors, compiler.NewError(context, message))
  3565  			}
  3566  			// check for valid enum values
  3567  			// [string number boolean integer array]
  3568  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
  3569  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v5))
  3570  				errors = append(errors, compiler.NewError(context, message))
  3571  			}
  3572  		}
  3573  		// string format = 6;
  3574  		v6 := compiler.MapValueForKey(m, "format")
  3575  		if v6 != nil {
  3576  			x.Format, ok = compiler.StringForScalarNode(v6)
  3577  			if !ok {
  3578  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v6))
  3579  				errors = append(errors, compiler.NewError(context, message))
  3580  			}
  3581  		}
  3582  		// PrimitivesItems items = 7;
  3583  		v7 := compiler.MapValueForKey(m, "items")
  3584  		if v7 != nil {
  3585  			var err error
  3586  			x.Items, err = NewPrimitivesItems(v7, compiler.NewContext("items", v7, context))
  3587  			if err != nil {
  3588  				errors = append(errors, err)
  3589  			}
  3590  		}
  3591  		// string collection_format = 8;
  3592  		v8 := compiler.MapValueForKey(m, "collectionFormat")
  3593  		if v8 != nil {
  3594  			x.CollectionFormat, ok = compiler.StringForScalarNode(v8)
  3595  			if !ok {
  3596  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v8))
  3597  				errors = append(errors, compiler.NewError(context, message))
  3598  			}
  3599  			// check for valid enum values
  3600  			// [csv ssv tsv pipes]
  3601  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
  3602  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v8))
  3603  				errors = append(errors, compiler.NewError(context, message))
  3604  			}
  3605  		}
  3606  		// Any default = 9;
  3607  		v9 := compiler.MapValueForKey(m, "default")
  3608  		if v9 != nil {
  3609  			var err error
  3610  			x.Default, err = NewAny(v9, compiler.NewContext("default", v9, context))
  3611  			if err != nil {
  3612  				errors = append(errors, err)
  3613  			}
  3614  		}
  3615  		// float maximum = 10;
  3616  		v10 := compiler.MapValueForKey(m, "maximum")
  3617  		if v10 != nil {
  3618  			v, ok := compiler.FloatForScalarNode(v10)
  3619  			if ok {
  3620  				x.Maximum = v
  3621  			} else {
  3622  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v10))
  3623  				errors = append(errors, compiler.NewError(context, message))
  3624  			}
  3625  		}
  3626  		// bool exclusive_maximum = 11;
  3627  		v11 := compiler.MapValueForKey(m, "exclusiveMaximum")
  3628  		if v11 != nil {
  3629  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v11)
  3630  			if !ok {
  3631  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v11))
  3632  				errors = append(errors, compiler.NewError(context, message))
  3633  			}
  3634  		}
  3635  		// float minimum = 12;
  3636  		v12 := compiler.MapValueForKey(m, "minimum")
  3637  		if v12 != nil {
  3638  			v, ok := compiler.FloatForScalarNode(v12)
  3639  			if ok {
  3640  				x.Minimum = v
  3641  			} else {
  3642  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v12))
  3643  				errors = append(errors, compiler.NewError(context, message))
  3644  			}
  3645  		}
  3646  		// bool exclusive_minimum = 13;
  3647  		v13 := compiler.MapValueForKey(m, "exclusiveMinimum")
  3648  		if v13 != nil {
  3649  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v13)
  3650  			if !ok {
  3651  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v13))
  3652  				errors = append(errors, compiler.NewError(context, message))
  3653  			}
  3654  		}
  3655  		// int64 max_length = 14;
  3656  		v14 := compiler.MapValueForKey(m, "maxLength")
  3657  		if v14 != nil {
  3658  			t, ok := compiler.IntForScalarNode(v14)
  3659  			if ok {
  3660  				x.MaxLength = int64(t)
  3661  			} else {
  3662  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v14))
  3663  				errors = append(errors, compiler.NewError(context, message))
  3664  			}
  3665  		}
  3666  		// int64 min_length = 15;
  3667  		v15 := compiler.MapValueForKey(m, "minLength")
  3668  		if v15 != nil {
  3669  			t, ok := compiler.IntForScalarNode(v15)
  3670  			if ok {
  3671  				x.MinLength = int64(t)
  3672  			} else {
  3673  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v15))
  3674  				errors = append(errors, compiler.NewError(context, message))
  3675  			}
  3676  		}
  3677  		// string pattern = 16;
  3678  		v16 := compiler.MapValueForKey(m, "pattern")
  3679  		if v16 != nil {
  3680  			x.Pattern, ok = compiler.StringForScalarNode(v16)
  3681  			if !ok {
  3682  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v16))
  3683  				errors = append(errors, compiler.NewError(context, message))
  3684  			}
  3685  		}
  3686  		// int64 max_items = 17;
  3687  		v17 := compiler.MapValueForKey(m, "maxItems")
  3688  		if v17 != nil {
  3689  			t, ok := compiler.IntForScalarNode(v17)
  3690  			if ok {
  3691  				x.MaxItems = int64(t)
  3692  			} else {
  3693  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v17))
  3694  				errors = append(errors, compiler.NewError(context, message))
  3695  			}
  3696  		}
  3697  		// int64 min_items = 18;
  3698  		v18 := compiler.MapValueForKey(m, "minItems")
  3699  		if v18 != nil {
  3700  			t, ok := compiler.IntForScalarNode(v18)
  3701  			if ok {
  3702  				x.MinItems = int64(t)
  3703  			} else {
  3704  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v18))
  3705  				errors = append(errors, compiler.NewError(context, message))
  3706  			}
  3707  		}
  3708  		// bool unique_items = 19;
  3709  		v19 := compiler.MapValueForKey(m, "uniqueItems")
  3710  		if v19 != nil {
  3711  			x.UniqueItems, ok = compiler.BoolForScalarNode(v19)
  3712  			if !ok {
  3713  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v19))
  3714  				errors = append(errors, compiler.NewError(context, message))
  3715  			}
  3716  		}
  3717  		// repeated Any enum = 20;
  3718  		v20 := compiler.MapValueForKey(m, "enum")
  3719  		if v20 != nil {
  3720  			// repeated Any
  3721  			x.Enum = make([]*Any, 0)
  3722  			a, ok := compiler.SequenceNodeForNode(v20)
  3723  			if ok {
  3724  				for _, item := range a.Content {
  3725  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  3726  					if err != nil {
  3727  						errors = append(errors, err)
  3728  					}
  3729  					x.Enum = append(x.Enum, y)
  3730  				}
  3731  			}
  3732  		}
  3733  		// float multiple_of = 21;
  3734  		v21 := compiler.MapValueForKey(m, "multipleOf")
  3735  		if v21 != nil {
  3736  			v, ok := compiler.FloatForScalarNode(v21)
  3737  			if ok {
  3738  				x.MultipleOf = v
  3739  			} else {
  3740  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v21))
  3741  				errors = append(errors, compiler.NewError(context, message))
  3742  			}
  3743  		}
  3744  		// repeated NamedAny vendor_extension = 22;
  3745  		// MAP: Any ^x-
  3746  		x.VendorExtension = make([]*NamedAny, 0)
  3747  		for i := 0; i < len(m.Content); i += 2 {
  3748  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3749  			if ok {
  3750  				v := m.Content[i+1]
  3751  				if strings.HasPrefix(k, "x-") {
  3752  					pair := &NamedAny{}
  3753  					pair.Name = k
  3754  					result := &Any{}
  3755  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  3756  					if handled {
  3757  						if err != nil {
  3758  							errors = append(errors, err)
  3759  						} else {
  3760  							bytes := compiler.Marshal(v)
  3761  							result.Yaml = string(bytes)
  3762  							result.Value = resultFromExt
  3763  							pair.Value = result
  3764  						}
  3765  					} else {
  3766  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  3767  						if err != nil {
  3768  							errors = append(errors, err)
  3769  						}
  3770  					}
  3771  					x.VendorExtension = append(x.VendorExtension, pair)
  3772  				}
  3773  			}
  3774  		}
  3775  	}
  3776  	return x, compiler.NewErrorGroupOrNil(errors)
  3777  }
  3778  
  3779  // NewPaths creates an object of type Paths if possible, returning an error if not.
  3780  func NewPaths(in *yaml.Node, context *compiler.Context) (*Paths, error) {
  3781  	errors := make([]error, 0)
  3782  	x := &Paths{}
  3783  	m, ok := compiler.UnpackMap(in)
  3784  	if !ok {
  3785  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3786  		errors = append(errors, compiler.NewError(context, message))
  3787  	} else {
  3788  		allowedKeys := []string{}
  3789  		allowedPatterns := []*regexp.Regexp{pattern0, pattern1}
  3790  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  3791  		if len(invalidKeys) > 0 {
  3792  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  3793  			errors = append(errors, compiler.NewError(context, message))
  3794  		}
  3795  		// repeated NamedAny vendor_extension = 1;
  3796  		// MAP: Any ^x-
  3797  		x.VendorExtension = make([]*NamedAny, 0)
  3798  		for i := 0; i < len(m.Content); i += 2 {
  3799  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3800  			if ok {
  3801  				v := m.Content[i+1]
  3802  				if strings.HasPrefix(k, "x-") {
  3803  					pair := &NamedAny{}
  3804  					pair.Name = k
  3805  					result := &Any{}
  3806  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  3807  					if handled {
  3808  						if err != nil {
  3809  							errors = append(errors, err)
  3810  						} else {
  3811  							bytes := compiler.Marshal(v)
  3812  							result.Yaml = string(bytes)
  3813  							result.Value = resultFromExt
  3814  							pair.Value = result
  3815  						}
  3816  					} else {
  3817  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  3818  						if err != nil {
  3819  							errors = append(errors, err)
  3820  						}
  3821  					}
  3822  					x.VendorExtension = append(x.VendorExtension, pair)
  3823  				}
  3824  			}
  3825  		}
  3826  		// repeated NamedPathItem path = 2;
  3827  		// MAP: PathItem ^/
  3828  		x.Path = make([]*NamedPathItem, 0)
  3829  		for i := 0; i < len(m.Content); i += 2 {
  3830  			k, ok := compiler.StringForScalarNode(m.Content[i])
  3831  			if ok {
  3832  				v := m.Content[i+1]
  3833  				if strings.HasPrefix(k, "/") {
  3834  					pair := &NamedPathItem{}
  3835  					pair.Name = k
  3836  					var err error
  3837  					pair.Value, err = NewPathItem(v, compiler.NewContext(k, v, context))
  3838  					if err != nil {
  3839  						errors = append(errors, err)
  3840  					}
  3841  					x.Path = append(x.Path, pair)
  3842  				}
  3843  			}
  3844  		}
  3845  	}
  3846  	return x, compiler.NewErrorGroupOrNil(errors)
  3847  }
  3848  
  3849  // NewPrimitivesItems creates an object of type PrimitivesItems if possible, returning an error if not.
  3850  func NewPrimitivesItems(in *yaml.Node, context *compiler.Context) (*PrimitivesItems, error) {
  3851  	errors := make([]error, 0)
  3852  	x := &PrimitivesItems{}
  3853  	m, ok := compiler.UnpackMap(in)
  3854  	if !ok {
  3855  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  3856  		errors = append(errors, compiler.NewError(context, message))
  3857  	} else {
  3858  		allowedKeys := []string{"collectionFormat", "default", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "pattern", "type", "uniqueItems"}
  3859  		allowedPatterns := []*regexp.Regexp{pattern0}
  3860  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  3861  		if len(invalidKeys) > 0 {
  3862  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  3863  			errors = append(errors, compiler.NewError(context, message))
  3864  		}
  3865  		// string type = 1;
  3866  		v1 := compiler.MapValueForKey(m, "type")
  3867  		if v1 != nil {
  3868  			x.Type, ok = compiler.StringForScalarNode(v1)
  3869  			if !ok {
  3870  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  3871  				errors = append(errors, compiler.NewError(context, message))
  3872  			}
  3873  			// check for valid enum values
  3874  			// [string number integer boolean array]
  3875  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "integer", "boolean", "array"}, x.Type) {
  3876  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
  3877  				errors = append(errors, compiler.NewError(context, message))
  3878  			}
  3879  		}
  3880  		// string format = 2;
  3881  		v2 := compiler.MapValueForKey(m, "format")
  3882  		if v2 != nil {
  3883  			x.Format, ok = compiler.StringForScalarNode(v2)
  3884  			if !ok {
  3885  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v2))
  3886  				errors = append(errors, compiler.NewError(context, message))
  3887  			}
  3888  		}
  3889  		// PrimitivesItems items = 3;
  3890  		v3 := compiler.MapValueForKey(m, "items")
  3891  		if v3 != nil {
  3892  			var err error
  3893  			x.Items, err = NewPrimitivesItems(v3, compiler.NewContext("items", v3, context))
  3894  			if err != nil {
  3895  				errors = append(errors, err)
  3896  			}
  3897  		}
  3898  		// string collection_format = 4;
  3899  		v4 := compiler.MapValueForKey(m, "collectionFormat")
  3900  		if v4 != nil {
  3901  			x.CollectionFormat, ok = compiler.StringForScalarNode(v4)
  3902  			if !ok {
  3903  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v4))
  3904  				errors = append(errors, compiler.NewError(context, message))
  3905  			}
  3906  			// check for valid enum values
  3907  			// [csv ssv tsv pipes]
  3908  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
  3909  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v4))
  3910  				errors = append(errors, compiler.NewError(context, message))
  3911  			}
  3912  		}
  3913  		// Any default = 5;
  3914  		v5 := compiler.MapValueForKey(m, "default")
  3915  		if v5 != nil {
  3916  			var err error
  3917  			x.Default, err = NewAny(v5, compiler.NewContext("default", v5, context))
  3918  			if err != nil {
  3919  				errors = append(errors, err)
  3920  			}
  3921  		}
  3922  		// float maximum = 6;
  3923  		v6 := compiler.MapValueForKey(m, "maximum")
  3924  		if v6 != nil {
  3925  			v, ok := compiler.FloatForScalarNode(v6)
  3926  			if ok {
  3927  				x.Maximum = v
  3928  			} else {
  3929  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v6))
  3930  				errors = append(errors, compiler.NewError(context, message))
  3931  			}
  3932  		}
  3933  		// bool exclusive_maximum = 7;
  3934  		v7 := compiler.MapValueForKey(m, "exclusiveMaximum")
  3935  		if v7 != nil {
  3936  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v7)
  3937  			if !ok {
  3938  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v7))
  3939  				errors = append(errors, compiler.NewError(context, message))
  3940  			}
  3941  		}
  3942  		// float minimum = 8;
  3943  		v8 := compiler.MapValueForKey(m, "minimum")
  3944  		if v8 != nil {
  3945  			v, ok := compiler.FloatForScalarNode(v8)
  3946  			if ok {
  3947  				x.Minimum = v
  3948  			} else {
  3949  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v8))
  3950  				errors = append(errors, compiler.NewError(context, message))
  3951  			}
  3952  		}
  3953  		// bool exclusive_minimum = 9;
  3954  		v9 := compiler.MapValueForKey(m, "exclusiveMinimum")
  3955  		if v9 != nil {
  3956  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v9)
  3957  			if !ok {
  3958  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v9))
  3959  				errors = append(errors, compiler.NewError(context, message))
  3960  			}
  3961  		}
  3962  		// int64 max_length = 10;
  3963  		v10 := compiler.MapValueForKey(m, "maxLength")
  3964  		if v10 != nil {
  3965  			t, ok := compiler.IntForScalarNode(v10)
  3966  			if ok {
  3967  				x.MaxLength = int64(t)
  3968  			} else {
  3969  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v10))
  3970  				errors = append(errors, compiler.NewError(context, message))
  3971  			}
  3972  		}
  3973  		// int64 min_length = 11;
  3974  		v11 := compiler.MapValueForKey(m, "minLength")
  3975  		if v11 != nil {
  3976  			t, ok := compiler.IntForScalarNode(v11)
  3977  			if ok {
  3978  				x.MinLength = int64(t)
  3979  			} else {
  3980  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v11))
  3981  				errors = append(errors, compiler.NewError(context, message))
  3982  			}
  3983  		}
  3984  		// string pattern = 12;
  3985  		v12 := compiler.MapValueForKey(m, "pattern")
  3986  		if v12 != nil {
  3987  			x.Pattern, ok = compiler.StringForScalarNode(v12)
  3988  			if !ok {
  3989  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v12))
  3990  				errors = append(errors, compiler.NewError(context, message))
  3991  			}
  3992  		}
  3993  		// int64 max_items = 13;
  3994  		v13 := compiler.MapValueForKey(m, "maxItems")
  3995  		if v13 != nil {
  3996  			t, ok := compiler.IntForScalarNode(v13)
  3997  			if ok {
  3998  				x.MaxItems = int64(t)
  3999  			} else {
  4000  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v13))
  4001  				errors = append(errors, compiler.NewError(context, message))
  4002  			}
  4003  		}
  4004  		// int64 min_items = 14;
  4005  		v14 := compiler.MapValueForKey(m, "minItems")
  4006  		if v14 != nil {
  4007  			t, ok := compiler.IntForScalarNode(v14)
  4008  			if ok {
  4009  				x.MinItems = int64(t)
  4010  			} else {
  4011  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v14))
  4012  				errors = append(errors, compiler.NewError(context, message))
  4013  			}
  4014  		}
  4015  		// bool unique_items = 15;
  4016  		v15 := compiler.MapValueForKey(m, "uniqueItems")
  4017  		if v15 != nil {
  4018  			x.UniqueItems, ok = compiler.BoolForScalarNode(v15)
  4019  			if !ok {
  4020  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v15))
  4021  				errors = append(errors, compiler.NewError(context, message))
  4022  			}
  4023  		}
  4024  		// repeated Any enum = 16;
  4025  		v16 := compiler.MapValueForKey(m, "enum")
  4026  		if v16 != nil {
  4027  			// repeated Any
  4028  			x.Enum = make([]*Any, 0)
  4029  			a, ok := compiler.SequenceNodeForNode(v16)
  4030  			if ok {
  4031  				for _, item := range a.Content {
  4032  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  4033  					if err != nil {
  4034  						errors = append(errors, err)
  4035  					}
  4036  					x.Enum = append(x.Enum, y)
  4037  				}
  4038  			}
  4039  		}
  4040  		// float multiple_of = 17;
  4041  		v17 := compiler.MapValueForKey(m, "multipleOf")
  4042  		if v17 != nil {
  4043  			v, ok := compiler.FloatForScalarNode(v17)
  4044  			if ok {
  4045  				x.MultipleOf = v
  4046  			} else {
  4047  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v17))
  4048  				errors = append(errors, compiler.NewError(context, message))
  4049  			}
  4050  		}
  4051  		// repeated NamedAny vendor_extension = 18;
  4052  		// MAP: Any ^x-
  4053  		x.VendorExtension = make([]*NamedAny, 0)
  4054  		for i := 0; i < len(m.Content); i += 2 {
  4055  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4056  			if ok {
  4057  				v := m.Content[i+1]
  4058  				if strings.HasPrefix(k, "x-") {
  4059  					pair := &NamedAny{}
  4060  					pair.Name = k
  4061  					result := &Any{}
  4062  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  4063  					if handled {
  4064  						if err != nil {
  4065  							errors = append(errors, err)
  4066  						} else {
  4067  							bytes := compiler.Marshal(v)
  4068  							result.Yaml = string(bytes)
  4069  							result.Value = resultFromExt
  4070  							pair.Value = result
  4071  						}
  4072  					} else {
  4073  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  4074  						if err != nil {
  4075  							errors = append(errors, err)
  4076  						}
  4077  					}
  4078  					x.VendorExtension = append(x.VendorExtension, pair)
  4079  				}
  4080  			}
  4081  		}
  4082  	}
  4083  	return x, compiler.NewErrorGroupOrNil(errors)
  4084  }
  4085  
  4086  // NewProperties creates an object of type Properties if possible, returning an error if not.
  4087  func NewProperties(in *yaml.Node, context *compiler.Context) (*Properties, error) {
  4088  	errors := make([]error, 0)
  4089  	x := &Properties{}
  4090  	m, ok := compiler.UnpackMap(in)
  4091  	if !ok {
  4092  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4093  		errors = append(errors, compiler.NewError(context, message))
  4094  	} else {
  4095  		// repeated NamedSchema additional_properties = 1;
  4096  		// MAP: Schema
  4097  		x.AdditionalProperties = make([]*NamedSchema, 0)
  4098  		for i := 0; i < len(m.Content); i += 2 {
  4099  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4100  			if ok {
  4101  				v := m.Content[i+1]
  4102  				pair := &NamedSchema{}
  4103  				pair.Name = k
  4104  				var err error
  4105  				pair.Value, err = NewSchema(v, compiler.NewContext(k, v, context))
  4106  				if err != nil {
  4107  					errors = append(errors, err)
  4108  				}
  4109  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  4110  			}
  4111  		}
  4112  	}
  4113  	return x, compiler.NewErrorGroupOrNil(errors)
  4114  }
  4115  
  4116  // NewQueryParameterSubSchema creates an object of type QueryParameterSubSchema if possible, returning an error if not.
  4117  func NewQueryParameterSubSchema(in *yaml.Node, context *compiler.Context) (*QueryParameterSubSchema, error) {
  4118  	errors := make([]error, 0)
  4119  	x := &QueryParameterSubSchema{}
  4120  	m, ok := compiler.UnpackMap(in)
  4121  	if !ok {
  4122  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4123  		errors = append(errors, compiler.NewError(context, message))
  4124  	} else {
  4125  		allowedKeys := []string{"allowEmptyValue", "collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
  4126  		allowedPatterns := []*regexp.Regexp{pattern0}
  4127  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  4128  		if len(invalidKeys) > 0 {
  4129  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  4130  			errors = append(errors, compiler.NewError(context, message))
  4131  		}
  4132  		// bool required = 1;
  4133  		v1 := compiler.MapValueForKey(m, "required")
  4134  		if v1 != nil {
  4135  			x.Required, ok = compiler.BoolForScalarNode(v1)
  4136  			if !ok {
  4137  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v1))
  4138  				errors = append(errors, compiler.NewError(context, message))
  4139  			}
  4140  		}
  4141  		// string in = 2;
  4142  		v2 := compiler.MapValueForKey(m, "in")
  4143  		if v2 != nil {
  4144  			x.In, ok = compiler.StringForScalarNode(v2)
  4145  			if !ok {
  4146  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  4147  				errors = append(errors, compiler.NewError(context, message))
  4148  			}
  4149  			// check for valid enum values
  4150  			// [query]
  4151  			if ok && !compiler.StringArrayContainsValue([]string{"query"}, x.In) {
  4152  				message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v2))
  4153  				errors = append(errors, compiler.NewError(context, message))
  4154  			}
  4155  		}
  4156  		// string description = 3;
  4157  		v3 := compiler.MapValueForKey(m, "description")
  4158  		if v3 != nil {
  4159  			x.Description, ok = compiler.StringForScalarNode(v3)
  4160  			if !ok {
  4161  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
  4162  				errors = append(errors, compiler.NewError(context, message))
  4163  			}
  4164  		}
  4165  		// string name = 4;
  4166  		v4 := compiler.MapValueForKey(m, "name")
  4167  		if v4 != nil {
  4168  			x.Name, ok = compiler.StringForScalarNode(v4)
  4169  			if !ok {
  4170  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v4))
  4171  				errors = append(errors, compiler.NewError(context, message))
  4172  			}
  4173  		}
  4174  		// bool allow_empty_value = 5;
  4175  		v5 := compiler.MapValueForKey(m, "allowEmptyValue")
  4176  		if v5 != nil {
  4177  			x.AllowEmptyValue, ok = compiler.BoolForScalarNode(v5)
  4178  			if !ok {
  4179  				message := fmt.Sprintf("has unexpected value for allowEmptyValue: %s", compiler.Display(v5))
  4180  				errors = append(errors, compiler.NewError(context, message))
  4181  			}
  4182  		}
  4183  		// string type = 6;
  4184  		v6 := compiler.MapValueForKey(m, "type")
  4185  		if v6 != nil {
  4186  			x.Type, ok = compiler.StringForScalarNode(v6)
  4187  			if !ok {
  4188  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
  4189  				errors = append(errors, compiler.NewError(context, message))
  4190  			}
  4191  			// check for valid enum values
  4192  			// [string number boolean integer array]
  4193  			if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
  4194  				message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v6))
  4195  				errors = append(errors, compiler.NewError(context, message))
  4196  			}
  4197  		}
  4198  		// string format = 7;
  4199  		v7 := compiler.MapValueForKey(m, "format")
  4200  		if v7 != nil {
  4201  			x.Format, ok = compiler.StringForScalarNode(v7)
  4202  			if !ok {
  4203  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v7))
  4204  				errors = append(errors, compiler.NewError(context, message))
  4205  			}
  4206  		}
  4207  		// PrimitivesItems items = 8;
  4208  		v8 := compiler.MapValueForKey(m, "items")
  4209  		if v8 != nil {
  4210  			var err error
  4211  			x.Items, err = NewPrimitivesItems(v8, compiler.NewContext("items", v8, context))
  4212  			if err != nil {
  4213  				errors = append(errors, err)
  4214  			}
  4215  		}
  4216  		// string collection_format = 9;
  4217  		v9 := compiler.MapValueForKey(m, "collectionFormat")
  4218  		if v9 != nil {
  4219  			x.CollectionFormat, ok = compiler.StringForScalarNode(v9)
  4220  			if !ok {
  4221  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v9))
  4222  				errors = append(errors, compiler.NewError(context, message))
  4223  			}
  4224  			// check for valid enum values
  4225  			// [csv ssv tsv pipes multi]
  4226  			if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes", "multi"}, x.CollectionFormat) {
  4227  				message := fmt.Sprintf("has unexpected value for collectionFormat: %s", compiler.Display(v9))
  4228  				errors = append(errors, compiler.NewError(context, message))
  4229  			}
  4230  		}
  4231  		// Any default = 10;
  4232  		v10 := compiler.MapValueForKey(m, "default")
  4233  		if v10 != nil {
  4234  			var err error
  4235  			x.Default, err = NewAny(v10, compiler.NewContext("default", v10, context))
  4236  			if err != nil {
  4237  				errors = append(errors, err)
  4238  			}
  4239  		}
  4240  		// float maximum = 11;
  4241  		v11 := compiler.MapValueForKey(m, "maximum")
  4242  		if v11 != nil {
  4243  			v, ok := compiler.FloatForScalarNode(v11)
  4244  			if ok {
  4245  				x.Maximum = v
  4246  			} else {
  4247  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v11))
  4248  				errors = append(errors, compiler.NewError(context, message))
  4249  			}
  4250  		}
  4251  		// bool exclusive_maximum = 12;
  4252  		v12 := compiler.MapValueForKey(m, "exclusiveMaximum")
  4253  		if v12 != nil {
  4254  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v12)
  4255  			if !ok {
  4256  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v12))
  4257  				errors = append(errors, compiler.NewError(context, message))
  4258  			}
  4259  		}
  4260  		// float minimum = 13;
  4261  		v13 := compiler.MapValueForKey(m, "minimum")
  4262  		if v13 != nil {
  4263  			v, ok := compiler.FloatForScalarNode(v13)
  4264  			if ok {
  4265  				x.Minimum = v
  4266  			} else {
  4267  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v13))
  4268  				errors = append(errors, compiler.NewError(context, message))
  4269  			}
  4270  		}
  4271  		// bool exclusive_minimum = 14;
  4272  		v14 := compiler.MapValueForKey(m, "exclusiveMinimum")
  4273  		if v14 != nil {
  4274  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v14)
  4275  			if !ok {
  4276  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v14))
  4277  				errors = append(errors, compiler.NewError(context, message))
  4278  			}
  4279  		}
  4280  		// int64 max_length = 15;
  4281  		v15 := compiler.MapValueForKey(m, "maxLength")
  4282  		if v15 != nil {
  4283  			t, ok := compiler.IntForScalarNode(v15)
  4284  			if ok {
  4285  				x.MaxLength = int64(t)
  4286  			} else {
  4287  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v15))
  4288  				errors = append(errors, compiler.NewError(context, message))
  4289  			}
  4290  		}
  4291  		// int64 min_length = 16;
  4292  		v16 := compiler.MapValueForKey(m, "minLength")
  4293  		if v16 != nil {
  4294  			t, ok := compiler.IntForScalarNode(v16)
  4295  			if ok {
  4296  				x.MinLength = int64(t)
  4297  			} else {
  4298  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v16))
  4299  				errors = append(errors, compiler.NewError(context, message))
  4300  			}
  4301  		}
  4302  		// string pattern = 17;
  4303  		v17 := compiler.MapValueForKey(m, "pattern")
  4304  		if v17 != nil {
  4305  			x.Pattern, ok = compiler.StringForScalarNode(v17)
  4306  			if !ok {
  4307  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v17))
  4308  				errors = append(errors, compiler.NewError(context, message))
  4309  			}
  4310  		}
  4311  		// int64 max_items = 18;
  4312  		v18 := compiler.MapValueForKey(m, "maxItems")
  4313  		if v18 != nil {
  4314  			t, ok := compiler.IntForScalarNode(v18)
  4315  			if ok {
  4316  				x.MaxItems = int64(t)
  4317  			} else {
  4318  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v18))
  4319  				errors = append(errors, compiler.NewError(context, message))
  4320  			}
  4321  		}
  4322  		// int64 min_items = 19;
  4323  		v19 := compiler.MapValueForKey(m, "minItems")
  4324  		if v19 != nil {
  4325  			t, ok := compiler.IntForScalarNode(v19)
  4326  			if ok {
  4327  				x.MinItems = int64(t)
  4328  			} else {
  4329  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v19))
  4330  				errors = append(errors, compiler.NewError(context, message))
  4331  			}
  4332  		}
  4333  		// bool unique_items = 20;
  4334  		v20 := compiler.MapValueForKey(m, "uniqueItems")
  4335  		if v20 != nil {
  4336  			x.UniqueItems, ok = compiler.BoolForScalarNode(v20)
  4337  			if !ok {
  4338  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v20))
  4339  				errors = append(errors, compiler.NewError(context, message))
  4340  			}
  4341  		}
  4342  		// repeated Any enum = 21;
  4343  		v21 := compiler.MapValueForKey(m, "enum")
  4344  		if v21 != nil {
  4345  			// repeated Any
  4346  			x.Enum = make([]*Any, 0)
  4347  			a, ok := compiler.SequenceNodeForNode(v21)
  4348  			if ok {
  4349  				for _, item := range a.Content {
  4350  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  4351  					if err != nil {
  4352  						errors = append(errors, err)
  4353  					}
  4354  					x.Enum = append(x.Enum, y)
  4355  				}
  4356  			}
  4357  		}
  4358  		// float multiple_of = 22;
  4359  		v22 := compiler.MapValueForKey(m, "multipleOf")
  4360  		if v22 != nil {
  4361  			v, ok := compiler.FloatForScalarNode(v22)
  4362  			if ok {
  4363  				x.MultipleOf = v
  4364  			} else {
  4365  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v22))
  4366  				errors = append(errors, compiler.NewError(context, message))
  4367  			}
  4368  		}
  4369  		// repeated NamedAny vendor_extension = 23;
  4370  		// MAP: Any ^x-
  4371  		x.VendorExtension = make([]*NamedAny, 0)
  4372  		for i := 0; i < len(m.Content); i += 2 {
  4373  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4374  			if ok {
  4375  				v := m.Content[i+1]
  4376  				if strings.HasPrefix(k, "x-") {
  4377  					pair := &NamedAny{}
  4378  					pair.Name = k
  4379  					result := &Any{}
  4380  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  4381  					if handled {
  4382  						if err != nil {
  4383  							errors = append(errors, err)
  4384  						} else {
  4385  							bytes := compiler.Marshal(v)
  4386  							result.Yaml = string(bytes)
  4387  							result.Value = resultFromExt
  4388  							pair.Value = result
  4389  						}
  4390  					} else {
  4391  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  4392  						if err != nil {
  4393  							errors = append(errors, err)
  4394  						}
  4395  					}
  4396  					x.VendorExtension = append(x.VendorExtension, pair)
  4397  				}
  4398  			}
  4399  		}
  4400  	}
  4401  	return x, compiler.NewErrorGroupOrNil(errors)
  4402  }
  4403  
  4404  // NewResponse creates an object of type Response if possible, returning an error if not.
  4405  func NewResponse(in *yaml.Node, context *compiler.Context) (*Response, error) {
  4406  	errors := make([]error, 0)
  4407  	x := &Response{}
  4408  	m, ok := compiler.UnpackMap(in)
  4409  	if !ok {
  4410  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4411  		errors = append(errors, compiler.NewError(context, message))
  4412  	} else {
  4413  		requiredKeys := []string{"description"}
  4414  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  4415  		if len(missingKeys) > 0 {
  4416  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  4417  			errors = append(errors, compiler.NewError(context, message))
  4418  		}
  4419  		allowedKeys := []string{"description", "examples", "headers", "schema"}
  4420  		allowedPatterns := []*regexp.Regexp{pattern0}
  4421  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  4422  		if len(invalidKeys) > 0 {
  4423  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  4424  			errors = append(errors, compiler.NewError(context, message))
  4425  		}
  4426  		// string description = 1;
  4427  		v1 := compiler.MapValueForKey(m, "description")
  4428  		if v1 != nil {
  4429  			x.Description, ok = compiler.StringForScalarNode(v1)
  4430  			if !ok {
  4431  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v1))
  4432  				errors = append(errors, compiler.NewError(context, message))
  4433  			}
  4434  		}
  4435  		// SchemaItem schema = 2;
  4436  		v2 := compiler.MapValueForKey(m, "schema")
  4437  		if v2 != nil {
  4438  			var err error
  4439  			x.Schema, err = NewSchemaItem(v2, compiler.NewContext("schema", v2, context))
  4440  			if err != nil {
  4441  				errors = append(errors, err)
  4442  			}
  4443  		}
  4444  		// Headers headers = 3;
  4445  		v3 := compiler.MapValueForKey(m, "headers")
  4446  		if v3 != nil {
  4447  			var err error
  4448  			x.Headers, err = NewHeaders(v3, compiler.NewContext("headers", v3, context))
  4449  			if err != nil {
  4450  				errors = append(errors, err)
  4451  			}
  4452  		}
  4453  		// Examples examples = 4;
  4454  		v4 := compiler.MapValueForKey(m, "examples")
  4455  		if v4 != nil {
  4456  			var err error
  4457  			x.Examples, err = NewExamples(v4, compiler.NewContext("examples", v4, context))
  4458  			if err != nil {
  4459  				errors = append(errors, err)
  4460  			}
  4461  		}
  4462  		// repeated NamedAny vendor_extension = 5;
  4463  		// MAP: Any ^x-
  4464  		x.VendorExtension = make([]*NamedAny, 0)
  4465  		for i := 0; i < len(m.Content); i += 2 {
  4466  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4467  			if ok {
  4468  				v := m.Content[i+1]
  4469  				if strings.HasPrefix(k, "x-") {
  4470  					pair := &NamedAny{}
  4471  					pair.Name = k
  4472  					result := &Any{}
  4473  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  4474  					if handled {
  4475  						if err != nil {
  4476  							errors = append(errors, err)
  4477  						} else {
  4478  							bytes := compiler.Marshal(v)
  4479  							result.Yaml = string(bytes)
  4480  							result.Value = resultFromExt
  4481  							pair.Value = result
  4482  						}
  4483  					} else {
  4484  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  4485  						if err != nil {
  4486  							errors = append(errors, err)
  4487  						}
  4488  					}
  4489  					x.VendorExtension = append(x.VendorExtension, pair)
  4490  				}
  4491  			}
  4492  		}
  4493  	}
  4494  	return x, compiler.NewErrorGroupOrNil(errors)
  4495  }
  4496  
  4497  // NewResponseDefinitions creates an object of type ResponseDefinitions if possible, returning an error if not.
  4498  func NewResponseDefinitions(in *yaml.Node, context *compiler.Context) (*ResponseDefinitions, error) {
  4499  	errors := make([]error, 0)
  4500  	x := &ResponseDefinitions{}
  4501  	m, ok := compiler.UnpackMap(in)
  4502  	if !ok {
  4503  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4504  		errors = append(errors, compiler.NewError(context, message))
  4505  	} else {
  4506  		// repeated NamedResponse additional_properties = 1;
  4507  		// MAP: Response
  4508  		x.AdditionalProperties = make([]*NamedResponse, 0)
  4509  		for i := 0; i < len(m.Content); i += 2 {
  4510  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4511  			if ok {
  4512  				v := m.Content[i+1]
  4513  				pair := &NamedResponse{}
  4514  				pair.Name = k
  4515  				var err error
  4516  				pair.Value, err = NewResponse(v, compiler.NewContext(k, v, context))
  4517  				if err != nil {
  4518  					errors = append(errors, err)
  4519  				}
  4520  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  4521  			}
  4522  		}
  4523  	}
  4524  	return x, compiler.NewErrorGroupOrNil(errors)
  4525  }
  4526  
  4527  // NewResponseValue creates an object of type ResponseValue if possible, returning an error if not.
  4528  func NewResponseValue(in *yaml.Node, context *compiler.Context) (*ResponseValue, error) {
  4529  	errors := make([]error, 0)
  4530  	x := &ResponseValue{}
  4531  	matched := false
  4532  	// Response response = 1;
  4533  	{
  4534  		m, ok := compiler.UnpackMap(in)
  4535  		if ok {
  4536  			// errors might be ok here, they mean we just don't have the right subtype
  4537  			t, matchingError := NewResponse(m, compiler.NewContext("response", m, context))
  4538  			if matchingError == nil {
  4539  				x.Oneof = &ResponseValue_Response{Response: t}
  4540  				matched = true
  4541  			} else {
  4542  				errors = append(errors, matchingError)
  4543  			}
  4544  		}
  4545  	}
  4546  	// JsonReference json_reference = 2;
  4547  	{
  4548  		m, ok := compiler.UnpackMap(in)
  4549  		if ok {
  4550  			// errors might be ok here, they mean we just don't have the right subtype
  4551  			t, matchingError := NewJsonReference(m, compiler.NewContext("jsonReference", m, context))
  4552  			if matchingError == nil {
  4553  				x.Oneof = &ResponseValue_JsonReference{JsonReference: t}
  4554  				matched = true
  4555  			} else {
  4556  				errors = append(errors, matchingError)
  4557  			}
  4558  		}
  4559  	}
  4560  	if matched {
  4561  		// since the oneof matched one of its possibilities, discard any matching errors
  4562  		errors = make([]error, 0)
  4563  	} else {
  4564  		message := fmt.Sprintf("contains an invalid ResponseValue")
  4565  		err := compiler.NewError(context, message)
  4566  		errors = []error{err}
  4567  	}
  4568  	return x, compiler.NewErrorGroupOrNil(errors)
  4569  }
  4570  
  4571  // NewResponses creates an object of type Responses if possible, returning an error if not.
  4572  func NewResponses(in *yaml.Node, context *compiler.Context) (*Responses, error) {
  4573  	errors := make([]error, 0)
  4574  	x := &Responses{}
  4575  	m, ok := compiler.UnpackMap(in)
  4576  	if !ok {
  4577  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4578  		errors = append(errors, compiler.NewError(context, message))
  4579  	} else {
  4580  		allowedKeys := []string{}
  4581  		allowedPatterns := []*regexp.Regexp{pattern2, pattern0}
  4582  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  4583  		if len(invalidKeys) > 0 {
  4584  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  4585  			errors = append(errors, compiler.NewError(context, message))
  4586  		}
  4587  		// repeated NamedResponseValue response_code = 1;
  4588  		// MAP: ResponseValue ^([0-9]{3})$|^(default)$
  4589  		x.ResponseCode = make([]*NamedResponseValue, 0)
  4590  		for i := 0; i < len(m.Content); i += 2 {
  4591  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4592  			if ok {
  4593  				v := m.Content[i+1]
  4594  				if pattern2.MatchString(k) {
  4595  					pair := &NamedResponseValue{}
  4596  					pair.Name = k
  4597  					var err error
  4598  					pair.Value, err = NewResponseValue(v, compiler.NewContext(k, v, context))
  4599  					if err != nil {
  4600  						errors = append(errors, err)
  4601  					}
  4602  					x.ResponseCode = append(x.ResponseCode, pair)
  4603  				}
  4604  			}
  4605  		}
  4606  		// repeated NamedAny vendor_extension = 2;
  4607  		// MAP: Any ^x-
  4608  		x.VendorExtension = make([]*NamedAny, 0)
  4609  		for i := 0; i < len(m.Content); i += 2 {
  4610  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4611  			if ok {
  4612  				v := m.Content[i+1]
  4613  				if strings.HasPrefix(k, "x-") {
  4614  					pair := &NamedAny{}
  4615  					pair.Name = k
  4616  					result := &Any{}
  4617  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  4618  					if handled {
  4619  						if err != nil {
  4620  							errors = append(errors, err)
  4621  						} else {
  4622  							bytes := compiler.Marshal(v)
  4623  							result.Yaml = string(bytes)
  4624  							result.Value = resultFromExt
  4625  							pair.Value = result
  4626  						}
  4627  					} else {
  4628  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  4629  						if err != nil {
  4630  							errors = append(errors, err)
  4631  						}
  4632  					}
  4633  					x.VendorExtension = append(x.VendorExtension, pair)
  4634  				}
  4635  			}
  4636  		}
  4637  	}
  4638  	return x, compiler.NewErrorGroupOrNil(errors)
  4639  }
  4640  
  4641  // NewSchema creates an object of type Schema if possible, returning an error if not.
  4642  func NewSchema(in *yaml.Node, context *compiler.Context) (*Schema, error) {
  4643  	errors := make([]error, 0)
  4644  	x := &Schema{}
  4645  	m, ok := compiler.UnpackMap(in)
  4646  	if !ok {
  4647  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  4648  		errors = append(errors, compiler.NewError(context, message))
  4649  	} else {
  4650  		allowedKeys := []string{"$ref", "additionalProperties", "allOf", "default", "description", "discriminator", "enum", "example", "exclusiveMaximum", "exclusiveMinimum", "externalDocs", "format", "items", "maxItems", "maxLength", "maxProperties", "maximum", "minItems", "minLength", "minProperties", "minimum", "multipleOf", "pattern", "properties", "readOnly", "required", "title", "type", "uniqueItems", "xml"}
  4651  		allowedPatterns := []*regexp.Regexp{pattern0}
  4652  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  4653  		if len(invalidKeys) > 0 {
  4654  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  4655  			errors = append(errors, compiler.NewError(context, message))
  4656  		}
  4657  		// string _ref = 1;
  4658  		v1 := compiler.MapValueForKey(m, "$ref")
  4659  		if v1 != nil {
  4660  			x.XRef, ok = compiler.StringForScalarNode(v1)
  4661  			if !ok {
  4662  				message := fmt.Sprintf("has unexpected value for $ref: %s", compiler.Display(v1))
  4663  				errors = append(errors, compiler.NewError(context, message))
  4664  			}
  4665  		}
  4666  		// string format = 2;
  4667  		v2 := compiler.MapValueForKey(m, "format")
  4668  		if v2 != nil {
  4669  			x.Format, ok = compiler.StringForScalarNode(v2)
  4670  			if !ok {
  4671  				message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v2))
  4672  				errors = append(errors, compiler.NewError(context, message))
  4673  			}
  4674  		}
  4675  		// string title = 3;
  4676  		v3 := compiler.MapValueForKey(m, "title")
  4677  		if v3 != nil {
  4678  			x.Title, ok = compiler.StringForScalarNode(v3)
  4679  			if !ok {
  4680  				message := fmt.Sprintf("has unexpected value for title: %s", compiler.Display(v3))
  4681  				errors = append(errors, compiler.NewError(context, message))
  4682  			}
  4683  		}
  4684  		// string description = 4;
  4685  		v4 := compiler.MapValueForKey(m, "description")
  4686  		if v4 != nil {
  4687  			x.Description, ok = compiler.StringForScalarNode(v4)
  4688  			if !ok {
  4689  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v4))
  4690  				errors = append(errors, compiler.NewError(context, message))
  4691  			}
  4692  		}
  4693  		// Any default = 5;
  4694  		v5 := compiler.MapValueForKey(m, "default")
  4695  		if v5 != nil {
  4696  			var err error
  4697  			x.Default, err = NewAny(v5, compiler.NewContext("default", v5, context))
  4698  			if err != nil {
  4699  				errors = append(errors, err)
  4700  			}
  4701  		}
  4702  		// float multiple_of = 6;
  4703  		v6 := compiler.MapValueForKey(m, "multipleOf")
  4704  		if v6 != nil {
  4705  			v, ok := compiler.FloatForScalarNode(v6)
  4706  			if ok {
  4707  				x.MultipleOf = v
  4708  			} else {
  4709  				message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v6))
  4710  				errors = append(errors, compiler.NewError(context, message))
  4711  			}
  4712  		}
  4713  		// float maximum = 7;
  4714  		v7 := compiler.MapValueForKey(m, "maximum")
  4715  		if v7 != nil {
  4716  			v, ok := compiler.FloatForScalarNode(v7)
  4717  			if ok {
  4718  				x.Maximum = v
  4719  			} else {
  4720  				message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v7))
  4721  				errors = append(errors, compiler.NewError(context, message))
  4722  			}
  4723  		}
  4724  		// bool exclusive_maximum = 8;
  4725  		v8 := compiler.MapValueForKey(m, "exclusiveMaximum")
  4726  		if v8 != nil {
  4727  			x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v8)
  4728  			if !ok {
  4729  				message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v8))
  4730  				errors = append(errors, compiler.NewError(context, message))
  4731  			}
  4732  		}
  4733  		// float minimum = 9;
  4734  		v9 := compiler.MapValueForKey(m, "minimum")
  4735  		if v9 != nil {
  4736  			v, ok := compiler.FloatForScalarNode(v9)
  4737  			if ok {
  4738  				x.Minimum = v
  4739  			} else {
  4740  				message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v9))
  4741  				errors = append(errors, compiler.NewError(context, message))
  4742  			}
  4743  		}
  4744  		// bool exclusive_minimum = 10;
  4745  		v10 := compiler.MapValueForKey(m, "exclusiveMinimum")
  4746  		if v10 != nil {
  4747  			x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v10)
  4748  			if !ok {
  4749  				message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v10))
  4750  				errors = append(errors, compiler.NewError(context, message))
  4751  			}
  4752  		}
  4753  		// int64 max_length = 11;
  4754  		v11 := compiler.MapValueForKey(m, "maxLength")
  4755  		if v11 != nil {
  4756  			t, ok := compiler.IntForScalarNode(v11)
  4757  			if ok {
  4758  				x.MaxLength = int64(t)
  4759  			} else {
  4760  				message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v11))
  4761  				errors = append(errors, compiler.NewError(context, message))
  4762  			}
  4763  		}
  4764  		// int64 min_length = 12;
  4765  		v12 := compiler.MapValueForKey(m, "minLength")
  4766  		if v12 != nil {
  4767  			t, ok := compiler.IntForScalarNode(v12)
  4768  			if ok {
  4769  				x.MinLength = int64(t)
  4770  			} else {
  4771  				message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v12))
  4772  				errors = append(errors, compiler.NewError(context, message))
  4773  			}
  4774  		}
  4775  		// string pattern = 13;
  4776  		v13 := compiler.MapValueForKey(m, "pattern")
  4777  		if v13 != nil {
  4778  			x.Pattern, ok = compiler.StringForScalarNode(v13)
  4779  			if !ok {
  4780  				message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v13))
  4781  				errors = append(errors, compiler.NewError(context, message))
  4782  			}
  4783  		}
  4784  		// int64 max_items = 14;
  4785  		v14 := compiler.MapValueForKey(m, "maxItems")
  4786  		if v14 != nil {
  4787  			t, ok := compiler.IntForScalarNode(v14)
  4788  			if ok {
  4789  				x.MaxItems = int64(t)
  4790  			} else {
  4791  				message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v14))
  4792  				errors = append(errors, compiler.NewError(context, message))
  4793  			}
  4794  		}
  4795  		// int64 min_items = 15;
  4796  		v15 := compiler.MapValueForKey(m, "minItems")
  4797  		if v15 != nil {
  4798  			t, ok := compiler.IntForScalarNode(v15)
  4799  			if ok {
  4800  				x.MinItems = int64(t)
  4801  			} else {
  4802  				message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v15))
  4803  				errors = append(errors, compiler.NewError(context, message))
  4804  			}
  4805  		}
  4806  		// bool unique_items = 16;
  4807  		v16 := compiler.MapValueForKey(m, "uniqueItems")
  4808  		if v16 != nil {
  4809  			x.UniqueItems, ok = compiler.BoolForScalarNode(v16)
  4810  			if !ok {
  4811  				message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v16))
  4812  				errors = append(errors, compiler.NewError(context, message))
  4813  			}
  4814  		}
  4815  		// int64 max_properties = 17;
  4816  		v17 := compiler.MapValueForKey(m, "maxProperties")
  4817  		if v17 != nil {
  4818  			t, ok := compiler.IntForScalarNode(v17)
  4819  			if ok {
  4820  				x.MaxProperties = int64(t)
  4821  			} else {
  4822  				message := fmt.Sprintf("has unexpected value for maxProperties: %s", compiler.Display(v17))
  4823  				errors = append(errors, compiler.NewError(context, message))
  4824  			}
  4825  		}
  4826  		// int64 min_properties = 18;
  4827  		v18 := compiler.MapValueForKey(m, "minProperties")
  4828  		if v18 != nil {
  4829  			t, ok := compiler.IntForScalarNode(v18)
  4830  			if ok {
  4831  				x.MinProperties = int64(t)
  4832  			} else {
  4833  				message := fmt.Sprintf("has unexpected value for minProperties: %s", compiler.Display(v18))
  4834  				errors = append(errors, compiler.NewError(context, message))
  4835  			}
  4836  		}
  4837  		// repeated string required = 19;
  4838  		v19 := compiler.MapValueForKey(m, "required")
  4839  		if v19 != nil {
  4840  			v, ok := compiler.SequenceNodeForNode(v19)
  4841  			if ok {
  4842  				x.Required = compiler.StringArrayForSequenceNode(v)
  4843  			} else {
  4844  				message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v19))
  4845  				errors = append(errors, compiler.NewError(context, message))
  4846  			}
  4847  		}
  4848  		// repeated Any enum = 20;
  4849  		v20 := compiler.MapValueForKey(m, "enum")
  4850  		if v20 != nil {
  4851  			// repeated Any
  4852  			x.Enum = make([]*Any, 0)
  4853  			a, ok := compiler.SequenceNodeForNode(v20)
  4854  			if ok {
  4855  				for _, item := range a.Content {
  4856  					y, err := NewAny(item, compiler.NewContext("enum", item, context))
  4857  					if err != nil {
  4858  						errors = append(errors, err)
  4859  					}
  4860  					x.Enum = append(x.Enum, y)
  4861  				}
  4862  			}
  4863  		}
  4864  		// AdditionalPropertiesItem additional_properties = 21;
  4865  		v21 := compiler.MapValueForKey(m, "additionalProperties")
  4866  		if v21 != nil {
  4867  			var err error
  4868  			x.AdditionalProperties, err = NewAdditionalPropertiesItem(v21, compiler.NewContext("additionalProperties", v21, context))
  4869  			if err != nil {
  4870  				errors = append(errors, err)
  4871  			}
  4872  		}
  4873  		// TypeItem type = 22;
  4874  		v22 := compiler.MapValueForKey(m, "type")
  4875  		if v22 != nil {
  4876  			var err error
  4877  			x.Type, err = NewTypeItem(v22, compiler.NewContext("type", v22, context))
  4878  			if err != nil {
  4879  				errors = append(errors, err)
  4880  			}
  4881  		}
  4882  		// ItemsItem items = 23;
  4883  		v23 := compiler.MapValueForKey(m, "items")
  4884  		if v23 != nil {
  4885  			var err error
  4886  			x.Items, err = NewItemsItem(v23, compiler.NewContext("items", v23, context))
  4887  			if err != nil {
  4888  				errors = append(errors, err)
  4889  			}
  4890  		}
  4891  		// repeated Schema all_of = 24;
  4892  		v24 := compiler.MapValueForKey(m, "allOf")
  4893  		if v24 != nil {
  4894  			// repeated Schema
  4895  			x.AllOf = make([]*Schema, 0)
  4896  			a, ok := compiler.SequenceNodeForNode(v24)
  4897  			if ok {
  4898  				for _, item := range a.Content {
  4899  					y, err := NewSchema(item, compiler.NewContext("allOf", item, context))
  4900  					if err != nil {
  4901  						errors = append(errors, err)
  4902  					}
  4903  					x.AllOf = append(x.AllOf, y)
  4904  				}
  4905  			}
  4906  		}
  4907  		// Properties properties = 25;
  4908  		v25 := compiler.MapValueForKey(m, "properties")
  4909  		if v25 != nil {
  4910  			var err error
  4911  			x.Properties, err = NewProperties(v25, compiler.NewContext("properties", v25, context))
  4912  			if err != nil {
  4913  				errors = append(errors, err)
  4914  			}
  4915  		}
  4916  		// string discriminator = 26;
  4917  		v26 := compiler.MapValueForKey(m, "discriminator")
  4918  		if v26 != nil {
  4919  			x.Discriminator, ok = compiler.StringForScalarNode(v26)
  4920  			if !ok {
  4921  				message := fmt.Sprintf("has unexpected value for discriminator: %s", compiler.Display(v26))
  4922  				errors = append(errors, compiler.NewError(context, message))
  4923  			}
  4924  		}
  4925  		// bool read_only = 27;
  4926  		v27 := compiler.MapValueForKey(m, "readOnly")
  4927  		if v27 != nil {
  4928  			x.ReadOnly, ok = compiler.BoolForScalarNode(v27)
  4929  			if !ok {
  4930  				message := fmt.Sprintf("has unexpected value for readOnly: %s", compiler.Display(v27))
  4931  				errors = append(errors, compiler.NewError(context, message))
  4932  			}
  4933  		}
  4934  		// Xml xml = 28;
  4935  		v28 := compiler.MapValueForKey(m, "xml")
  4936  		if v28 != nil {
  4937  			var err error
  4938  			x.Xml, err = NewXml(v28, compiler.NewContext("xml", v28, context))
  4939  			if err != nil {
  4940  				errors = append(errors, err)
  4941  			}
  4942  		}
  4943  		// ExternalDocs external_docs = 29;
  4944  		v29 := compiler.MapValueForKey(m, "externalDocs")
  4945  		if v29 != nil {
  4946  			var err error
  4947  			x.ExternalDocs, err = NewExternalDocs(v29, compiler.NewContext("externalDocs", v29, context))
  4948  			if err != nil {
  4949  				errors = append(errors, err)
  4950  			}
  4951  		}
  4952  		// Any example = 30;
  4953  		v30 := compiler.MapValueForKey(m, "example")
  4954  		if v30 != nil {
  4955  			var err error
  4956  			x.Example, err = NewAny(v30, compiler.NewContext("example", v30, context))
  4957  			if err != nil {
  4958  				errors = append(errors, err)
  4959  			}
  4960  		}
  4961  		// repeated NamedAny vendor_extension = 31;
  4962  		// MAP: Any ^x-
  4963  		x.VendorExtension = make([]*NamedAny, 0)
  4964  		for i := 0; i < len(m.Content); i += 2 {
  4965  			k, ok := compiler.StringForScalarNode(m.Content[i])
  4966  			if ok {
  4967  				v := m.Content[i+1]
  4968  				if strings.HasPrefix(k, "x-") {
  4969  					pair := &NamedAny{}
  4970  					pair.Name = k
  4971  					result := &Any{}
  4972  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  4973  					if handled {
  4974  						if err != nil {
  4975  							errors = append(errors, err)
  4976  						} else {
  4977  							bytes := compiler.Marshal(v)
  4978  							result.Yaml = string(bytes)
  4979  							result.Value = resultFromExt
  4980  							pair.Value = result
  4981  						}
  4982  					} else {
  4983  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  4984  						if err != nil {
  4985  							errors = append(errors, err)
  4986  						}
  4987  					}
  4988  					x.VendorExtension = append(x.VendorExtension, pair)
  4989  				}
  4990  			}
  4991  		}
  4992  	}
  4993  	return x, compiler.NewErrorGroupOrNil(errors)
  4994  }
  4995  
  4996  // NewSchemaItem creates an object of type SchemaItem if possible, returning an error if not.
  4997  func NewSchemaItem(in *yaml.Node, context *compiler.Context) (*SchemaItem, error) {
  4998  	errors := make([]error, 0)
  4999  	x := &SchemaItem{}
  5000  	matched := false
  5001  	// Schema schema = 1;
  5002  	{
  5003  		m, ok := compiler.UnpackMap(in)
  5004  		if ok {
  5005  			// errors might be ok here, they mean we just don't have the right subtype
  5006  			t, matchingError := NewSchema(m, compiler.NewContext("schema", m, context))
  5007  			if matchingError == nil {
  5008  				x.Oneof = &SchemaItem_Schema{Schema: t}
  5009  				matched = true
  5010  			} else {
  5011  				errors = append(errors, matchingError)
  5012  			}
  5013  		}
  5014  	}
  5015  	// FileSchema file_schema = 2;
  5016  	{
  5017  		m, ok := compiler.UnpackMap(in)
  5018  		if ok {
  5019  			// errors might be ok here, they mean we just don't have the right subtype
  5020  			t, matchingError := NewFileSchema(m, compiler.NewContext("fileSchema", m, context))
  5021  			if matchingError == nil {
  5022  				x.Oneof = &SchemaItem_FileSchema{FileSchema: t}
  5023  				matched = true
  5024  			} else {
  5025  				errors = append(errors, matchingError)
  5026  			}
  5027  		}
  5028  	}
  5029  	if matched {
  5030  		// since the oneof matched one of its possibilities, discard any matching errors
  5031  		errors = make([]error, 0)
  5032  	} else {
  5033  		message := fmt.Sprintf("contains an invalid SchemaItem")
  5034  		err := compiler.NewError(context, message)
  5035  		errors = []error{err}
  5036  	}
  5037  	return x, compiler.NewErrorGroupOrNil(errors)
  5038  }
  5039  
  5040  // NewSecurityDefinitions creates an object of type SecurityDefinitions if possible, returning an error if not.
  5041  func NewSecurityDefinitions(in *yaml.Node, context *compiler.Context) (*SecurityDefinitions, error) {
  5042  	errors := make([]error, 0)
  5043  	x := &SecurityDefinitions{}
  5044  	m, ok := compiler.UnpackMap(in)
  5045  	if !ok {
  5046  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  5047  		errors = append(errors, compiler.NewError(context, message))
  5048  	} else {
  5049  		// repeated NamedSecurityDefinitionsItem additional_properties = 1;
  5050  		// MAP: SecurityDefinitionsItem
  5051  		x.AdditionalProperties = make([]*NamedSecurityDefinitionsItem, 0)
  5052  		for i := 0; i < len(m.Content); i += 2 {
  5053  			k, ok := compiler.StringForScalarNode(m.Content[i])
  5054  			if ok {
  5055  				v := m.Content[i+1]
  5056  				pair := &NamedSecurityDefinitionsItem{}
  5057  				pair.Name = k
  5058  				var err error
  5059  				pair.Value, err = NewSecurityDefinitionsItem(v, compiler.NewContext(k, v, context))
  5060  				if err != nil {
  5061  					errors = append(errors, err)
  5062  				}
  5063  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  5064  			}
  5065  		}
  5066  	}
  5067  	return x, compiler.NewErrorGroupOrNil(errors)
  5068  }
  5069  
  5070  // NewSecurityDefinitionsItem creates an object of type SecurityDefinitionsItem if possible, returning an error if not.
  5071  func NewSecurityDefinitionsItem(in *yaml.Node, context *compiler.Context) (*SecurityDefinitionsItem, error) {
  5072  	errors := make([]error, 0)
  5073  	x := &SecurityDefinitionsItem{}
  5074  	matched := false
  5075  	// BasicAuthenticationSecurity basic_authentication_security = 1;
  5076  	{
  5077  		m, ok := compiler.UnpackMap(in)
  5078  		if ok {
  5079  			// errors might be ok here, they mean we just don't have the right subtype
  5080  			t, matchingError := NewBasicAuthenticationSecurity(m, compiler.NewContext("basicAuthenticationSecurity", m, context))
  5081  			if matchingError == nil {
  5082  				x.Oneof = &SecurityDefinitionsItem_BasicAuthenticationSecurity{BasicAuthenticationSecurity: t}
  5083  				matched = true
  5084  			} else {
  5085  				errors = append(errors, matchingError)
  5086  			}
  5087  		}
  5088  	}
  5089  	// ApiKeySecurity api_key_security = 2;
  5090  	{
  5091  		m, ok := compiler.UnpackMap(in)
  5092  		if ok {
  5093  			// errors might be ok here, they mean we just don't have the right subtype
  5094  			t, matchingError := NewApiKeySecurity(m, compiler.NewContext("apiKeySecurity", m, context))
  5095  			if matchingError == nil {
  5096  				x.Oneof = &SecurityDefinitionsItem_ApiKeySecurity{ApiKeySecurity: t}
  5097  				matched = true
  5098  			} else {
  5099  				errors = append(errors, matchingError)
  5100  			}
  5101  		}
  5102  	}
  5103  	// Oauth2ImplicitSecurity oauth2_implicit_security = 3;
  5104  	{
  5105  		m, ok := compiler.UnpackMap(in)
  5106  		if ok {
  5107  			// errors might be ok here, they mean we just don't have the right subtype
  5108  			t, matchingError := NewOauth2ImplicitSecurity(m, compiler.NewContext("oauth2ImplicitSecurity", m, context))
  5109  			if matchingError == nil {
  5110  				x.Oneof = &SecurityDefinitionsItem_Oauth2ImplicitSecurity{Oauth2ImplicitSecurity: t}
  5111  				matched = true
  5112  			} else {
  5113  				errors = append(errors, matchingError)
  5114  			}
  5115  		}
  5116  	}
  5117  	// Oauth2PasswordSecurity oauth2_password_security = 4;
  5118  	{
  5119  		m, ok := compiler.UnpackMap(in)
  5120  		if ok {
  5121  			// errors might be ok here, they mean we just don't have the right subtype
  5122  			t, matchingError := NewOauth2PasswordSecurity(m, compiler.NewContext("oauth2PasswordSecurity", m, context))
  5123  			if matchingError == nil {
  5124  				x.Oneof = &SecurityDefinitionsItem_Oauth2PasswordSecurity{Oauth2PasswordSecurity: t}
  5125  				matched = true
  5126  			} else {
  5127  				errors = append(errors, matchingError)
  5128  			}
  5129  		}
  5130  	}
  5131  	// Oauth2ApplicationSecurity oauth2_application_security = 5;
  5132  	{
  5133  		m, ok := compiler.UnpackMap(in)
  5134  		if ok {
  5135  			// errors might be ok here, they mean we just don't have the right subtype
  5136  			t, matchingError := NewOauth2ApplicationSecurity(m, compiler.NewContext("oauth2ApplicationSecurity", m, context))
  5137  			if matchingError == nil {
  5138  				x.Oneof = &SecurityDefinitionsItem_Oauth2ApplicationSecurity{Oauth2ApplicationSecurity: t}
  5139  				matched = true
  5140  			} else {
  5141  				errors = append(errors, matchingError)
  5142  			}
  5143  		}
  5144  	}
  5145  	// Oauth2AccessCodeSecurity oauth2_access_code_security = 6;
  5146  	{
  5147  		m, ok := compiler.UnpackMap(in)
  5148  		if ok {
  5149  			// errors might be ok here, they mean we just don't have the right subtype
  5150  			t, matchingError := NewOauth2AccessCodeSecurity(m, compiler.NewContext("oauth2AccessCodeSecurity", m, context))
  5151  			if matchingError == nil {
  5152  				x.Oneof = &SecurityDefinitionsItem_Oauth2AccessCodeSecurity{Oauth2AccessCodeSecurity: t}
  5153  				matched = true
  5154  			} else {
  5155  				errors = append(errors, matchingError)
  5156  			}
  5157  		}
  5158  	}
  5159  	if matched {
  5160  		// since the oneof matched one of its possibilities, discard any matching errors
  5161  		errors = make([]error, 0)
  5162  	} else {
  5163  		message := fmt.Sprintf("contains an invalid SecurityDefinitionsItem")
  5164  		err := compiler.NewError(context, message)
  5165  		errors = []error{err}
  5166  	}
  5167  	return x, compiler.NewErrorGroupOrNil(errors)
  5168  }
  5169  
  5170  // NewSecurityRequirement creates an object of type SecurityRequirement if possible, returning an error if not.
  5171  func NewSecurityRequirement(in *yaml.Node, context *compiler.Context) (*SecurityRequirement, error) {
  5172  	errors := make([]error, 0)
  5173  	x := &SecurityRequirement{}
  5174  	m, ok := compiler.UnpackMap(in)
  5175  	if !ok {
  5176  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  5177  		errors = append(errors, compiler.NewError(context, message))
  5178  	} else {
  5179  		// repeated NamedStringArray additional_properties = 1;
  5180  		// MAP: StringArray
  5181  		x.AdditionalProperties = make([]*NamedStringArray, 0)
  5182  		for i := 0; i < len(m.Content); i += 2 {
  5183  			k, ok := compiler.StringForScalarNode(m.Content[i])
  5184  			if ok {
  5185  				v := m.Content[i+1]
  5186  				pair := &NamedStringArray{}
  5187  				pair.Name = k
  5188  				var err error
  5189  				pair.Value, err = NewStringArray(v, compiler.NewContext(k, v, context))
  5190  				if err != nil {
  5191  					errors = append(errors, err)
  5192  				}
  5193  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  5194  			}
  5195  		}
  5196  	}
  5197  	return x, compiler.NewErrorGroupOrNil(errors)
  5198  }
  5199  
  5200  // NewStringArray creates an object of type StringArray if possible, returning an error if not.
  5201  func NewStringArray(in *yaml.Node, context *compiler.Context) (*StringArray, error) {
  5202  	errors := make([]error, 0)
  5203  	x := &StringArray{}
  5204  	x.Value = make([]string, 0)
  5205  	for _, node := range in.Content {
  5206  		s, _ := compiler.StringForScalarNode(node)
  5207  		x.Value = append(x.Value, s)
  5208  	}
  5209  	return x, compiler.NewErrorGroupOrNil(errors)
  5210  }
  5211  
  5212  // NewTag creates an object of type Tag if possible, returning an error if not.
  5213  func NewTag(in *yaml.Node, context *compiler.Context) (*Tag, error) {
  5214  	errors := make([]error, 0)
  5215  	x := &Tag{}
  5216  	m, ok := compiler.UnpackMap(in)
  5217  	if !ok {
  5218  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  5219  		errors = append(errors, compiler.NewError(context, message))
  5220  	} else {
  5221  		requiredKeys := []string{"name"}
  5222  		missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
  5223  		if len(missingKeys) > 0 {
  5224  			message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
  5225  			errors = append(errors, compiler.NewError(context, message))
  5226  		}
  5227  		allowedKeys := []string{"description", "externalDocs", "name"}
  5228  		allowedPatterns := []*regexp.Regexp{pattern0}
  5229  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  5230  		if len(invalidKeys) > 0 {
  5231  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  5232  			errors = append(errors, compiler.NewError(context, message))
  5233  		}
  5234  		// string name = 1;
  5235  		v1 := compiler.MapValueForKey(m, "name")
  5236  		if v1 != nil {
  5237  			x.Name, ok = compiler.StringForScalarNode(v1)
  5238  			if !ok {
  5239  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  5240  				errors = append(errors, compiler.NewError(context, message))
  5241  			}
  5242  		}
  5243  		// string description = 2;
  5244  		v2 := compiler.MapValueForKey(m, "description")
  5245  		if v2 != nil {
  5246  			x.Description, ok = compiler.StringForScalarNode(v2)
  5247  			if !ok {
  5248  				message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
  5249  				errors = append(errors, compiler.NewError(context, message))
  5250  			}
  5251  		}
  5252  		// ExternalDocs external_docs = 3;
  5253  		v3 := compiler.MapValueForKey(m, "externalDocs")
  5254  		if v3 != nil {
  5255  			var err error
  5256  			x.ExternalDocs, err = NewExternalDocs(v3, compiler.NewContext("externalDocs", v3, context))
  5257  			if err != nil {
  5258  				errors = append(errors, err)
  5259  			}
  5260  		}
  5261  		// repeated NamedAny vendor_extension = 4;
  5262  		// MAP: Any ^x-
  5263  		x.VendorExtension = make([]*NamedAny, 0)
  5264  		for i := 0; i < len(m.Content); i += 2 {
  5265  			k, ok := compiler.StringForScalarNode(m.Content[i])
  5266  			if ok {
  5267  				v := m.Content[i+1]
  5268  				if strings.HasPrefix(k, "x-") {
  5269  					pair := &NamedAny{}
  5270  					pair.Name = k
  5271  					result := &Any{}
  5272  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  5273  					if handled {
  5274  						if err != nil {
  5275  							errors = append(errors, err)
  5276  						} else {
  5277  							bytes := compiler.Marshal(v)
  5278  							result.Yaml = string(bytes)
  5279  							result.Value = resultFromExt
  5280  							pair.Value = result
  5281  						}
  5282  					} else {
  5283  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  5284  						if err != nil {
  5285  							errors = append(errors, err)
  5286  						}
  5287  					}
  5288  					x.VendorExtension = append(x.VendorExtension, pair)
  5289  				}
  5290  			}
  5291  		}
  5292  	}
  5293  	return x, compiler.NewErrorGroupOrNil(errors)
  5294  }
  5295  
  5296  // NewTypeItem creates an object of type TypeItem if possible, returning an error if not.
  5297  func NewTypeItem(in *yaml.Node, context *compiler.Context) (*TypeItem, error) {
  5298  	errors := make([]error, 0)
  5299  	x := &TypeItem{}
  5300  	v1 := in
  5301  	switch v1.Kind {
  5302  	case yaml.ScalarNode:
  5303  		x.Value = make([]string, 0)
  5304  		x.Value = append(x.Value, v1.Value)
  5305  	case yaml.SequenceNode:
  5306  		x.Value = make([]string, 0)
  5307  		for _, v := range v1.Content {
  5308  			value := v.Value
  5309  			ok := v.Kind == yaml.ScalarNode
  5310  			if ok {
  5311  				x.Value = append(x.Value, value)
  5312  			} else {
  5313  				message := fmt.Sprintf("has unexpected value for string array element: %+v (%T)", value, value)
  5314  				errors = append(errors, compiler.NewError(context, message))
  5315  			}
  5316  		}
  5317  	default:
  5318  		message := fmt.Sprintf("has unexpected value for string array: %+v (%T)", in, in)
  5319  		errors = append(errors, compiler.NewError(context, message))
  5320  	}
  5321  	return x, compiler.NewErrorGroupOrNil(errors)
  5322  }
  5323  
  5324  // NewVendorExtension creates an object of type VendorExtension if possible, returning an error if not.
  5325  func NewVendorExtension(in *yaml.Node, context *compiler.Context) (*VendorExtension, error) {
  5326  	errors := make([]error, 0)
  5327  	x := &VendorExtension{}
  5328  	m, ok := compiler.UnpackMap(in)
  5329  	if !ok {
  5330  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  5331  		errors = append(errors, compiler.NewError(context, message))
  5332  	} else {
  5333  		// repeated NamedAny additional_properties = 1;
  5334  		// MAP: Any
  5335  		x.AdditionalProperties = make([]*NamedAny, 0)
  5336  		for i := 0; i < len(m.Content); i += 2 {
  5337  			k, ok := compiler.StringForScalarNode(m.Content[i])
  5338  			if ok {
  5339  				v := m.Content[i+1]
  5340  				pair := &NamedAny{}
  5341  				pair.Name = k
  5342  				result := &Any{}
  5343  				handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  5344  				if handled {
  5345  					if err != nil {
  5346  						errors = append(errors, err)
  5347  					} else {
  5348  						bytes := compiler.Marshal(v)
  5349  						result.Yaml = string(bytes)
  5350  						result.Value = resultFromExt
  5351  						pair.Value = result
  5352  					}
  5353  				} else {
  5354  					pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  5355  					if err != nil {
  5356  						errors = append(errors, err)
  5357  					}
  5358  				}
  5359  				x.AdditionalProperties = append(x.AdditionalProperties, pair)
  5360  			}
  5361  		}
  5362  	}
  5363  	return x, compiler.NewErrorGroupOrNil(errors)
  5364  }
  5365  
  5366  // NewXml creates an object of type Xml if possible, returning an error if not.
  5367  func NewXml(in *yaml.Node, context *compiler.Context) (*Xml, error) {
  5368  	errors := make([]error, 0)
  5369  	x := &Xml{}
  5370  	m, ok := compiler.UnpackMap(in)
  5371  	if !ok {
  5372  		message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
  5373  		errors = append(errors, compiler.NewError(context, message))
  5374  	} else {
  5375  		allowedKeys := []string{"attribute", "name", "namespace", "prefix", "wrapped"}
  5376  		allowedPatterns := []*regexp.Regexp{pattern0}
  5377  		invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
  5378  		if len(invalidKeys) > 0 {
  5379  			message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
  5380  			errors = append(errors, compiler.NewError(context, message))
  5381  		}
  5382  		// string name = 1;
  5383  		v1 := compiler.MapValueForKey(m, "name")
  5384  		if v1 != nil {
  5385  			x.Name, ok = compiler.StringForScalarNode(v1)
  5386  			if !ok {
  5387  				message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
  5388  				errors = append(errors, compiler.NewError(context, message))
  5389  			}
  5390  		}
  5391  		// string namespace = 2;
  5392  		v2 := compiler.MapValueForKey(m, "namespace")
  5393  		if v2 != nil {
  5394  			x.Namespace, ok = compiler.StringForScalarNode(v2)
  5395  			if !ok {
  5396  				message := fmt.Sprintf("has unexpected value for namespace: %s", compiler.Display(v2))
  5397  				errors = append(errors, compiler.NewError(context, message))
  5398  			}
  5399  		}
  5400  		// string prefix = 3;
  5401  		v3 := compiler.MapValueForKey(m, "prefix")
  5402  		if v3 != nil {
  5403  			x.Prefix, ok = compiler.StringForScalarNode(v3)
  5404  			if !ok {
  5405  				message := fmt.Sprintf("has unexpected value for prefix: %s", compiler.Display(v3))
  5406  				errors = append(errors, compiler.NewError(context, message))
  5407  			}
  5408  		}
  5409  		// bool attribute = 4;
  5410  		v4 := compiler.MapValueForKey(m, "attribute")
  5411  		if v4 != nil {
  5412  			x.Attribute, ok = compiler.BoolForScalarNode(v4)
  5413  			if !ok {
  5414  				message := fmt.Sprintf("has unexpected value for attribute: %s", compiler.Display(v4))
  5415  				errors = append(errors, compiler.NewError(context, message))
  5416  			}
  5417  		}
  5418  		// bool wrapped = 5;
  5419  		v5 := compiler.MapValueForKey(m, "wrapped")
  5420  		if v5 != nil {
  5421  			x.Wrapped, ok = compiler.BoolForScalarNode(v5)
  5422  			if !ok {
  5423  				message := fmt.Sprintf("has unexpected value for wrapped: %s", compiler.Display(v5))
  5424  				errors = append(errors, compiler.NewError(context, message))
  5425  			}
  5426  		}
  5427  		// repeated NamedAny vendor_extension = 6;
  5428  		// MAP: Any ^x-
  5429  		x.VendorExtension = make([]*NamedAny, 0)
  5430  		for i := 0; i < len(m.Content); i += 2 {
  5431  			k, ok := compiler.StringForScalarNode(m.Content[i])
  5432  			if ok {
  5433  				v := m.Content[i+1]
  5434  				if strings.HasPrefix(k, "x-") {
  5435  					pair := &NamedAny{}
  5436  					pair.Name = k
  5437  					result := &Any{}
  5438  					handled, resultFromExt, err := compiler.CallExtension(context, v, k)
  5439  					if handled {
  5440  						if err != nil {
  5441  							errors = append(errors, err)
  5442  						} else {
  5443  							bytes := compiler.Marshal(v)
  5444  							result.Yaml = string(bytes)
  5445  							result.Value = resultFromExt
  5446  							pair.Value = result
  5447  						}
  5448  					} else {
  5449  						pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
  5450  						if err != nil {
  5451  							errors = append(errors, err)
  5452  						}
  5453  					}
  5454  					x.VendorExtension = append(x.VendorExtension, pair)
  5455  				}
  5456  			}
  5457  		}
  5458  	}
  5459  	return x, compiler.NewErrorGroupOrNil(errors)
  5460  }
  5461  
  5462  // ResolveReferences resolves references found inside AdditionalPropertiesItem objects.
  5463  func (m *AdditionalPropertiesItem) ResolveReferences(root string) (*yaml.Node, error) {
  5464  	errors := make([]error, 0)
  5465  	{
  5466  		p, ok := m.Oneof.(*AdditionalPropertiesItem_Schema)
  5467  		if ok {
  5468  			_, err := p.Schema.ResolveReferences(root)
  5469  			if err != nil {
  5470  				return nil, err
  5471  			}
  5472  		}
  5473  	}
  5474  	return nil, compiler.NewErrorGroupOrNil(errors)
  5475  }
  5476  
  5477  // ResolveReferences resolves references found inside Any objects.
  5478  func (m *Any) ResolveReferences(root string) (*yaml.Node, error) {
  5479  	errors := make([]error, 0)
  5480  	return nil, compiler.NewErrorGroupOrNil(errors)
  5481  }
  5482  
  5483  // ResolveReferences resolves references found inside ApiKeySecurity objects.
  5484  func (m *ApiKeySecurity) ResolveReferences(root string) (*yaml.Node, error) {
  5485  	errors := make([]error, 0)
  5486  	for _, item := range m.VendorExtension {
  5487  		if item != nil {
  5488  			_, err := item.ResolveReferences(root)
  5489  			if err != nil {
  5490  				errors = append(errors, err)
  5491  			}
  5492  		}
  5493  	}
  5494  	return nil, compiler.NewErrorGroupOrNil(errors)
  5495  }
  5496  
  5497  // ResolveReferences resolves references found inside BasicAuthenticationSecurity objects.
  5498  func (m *BasicAuthenticationSecurity) ResolveReferences(root string) (*yaml.Node, error) {
  5499  	errors := make([]error, 0)
  5500  	for _, item := range m.VendorExtension {
  5501  		if item != nil {
  5502  			_, err := item.ResolveReferences(root)
  5503  			if err != nil {
  5504  				errors = append(errors, err)
  5505  			}
  5506  		}
  5507  	}
  5508  	return nil, compiler.NewErrorGroupOrNil(errors)
  5509  }
  5510  
  5511  // ResolveReferences resolves references found inside BodyParameter objects.
  5512  func (m *BodyParameter) ResolveReferences(root string) (*yaml.Node, error) {
  5513  	errors := make([]error, 0)
  5514  	if m.Schema != nil {
  5515  		_, err := m.Schema.ResolveReferences(root)
  5516  		if err != nil {
  5517  			errors = append(errors, err)
  5518  		}
  5519  	}
  5520  	for _, item := range m.VendorExtension {
  5521  		if item != nil {
  5522  			_, err := item.ResolveReferences(root)
  5523  			if err != nil {
  5524  				errors = append(errors, err)
  5525  			}
  5526  		}
  5527  	}
  5528  	return nil, compiler.NewErrorGroupOrNil(errors)
  5529  }
  5530  
  5531  // ResolveReferences resolves references found inside Contact objects.
  5532  func (m *Contact) ResolveReferences(root string) (*yaml.Node, error) {
  5533  	errors := make([]error, 0)
  5534  	for _, item := range m.VendorExtension {
  5535  		if item != nil {
  5536  			_, err := item.ResolveReferences(root)
  5537  			if err != nil {
  5538  				errors = append(errors, err)
  5539  			}
  5540  		}
  5541  	}
  5542  	return nil, compiler.NewErrorGroupOrNil(errors)
  5543  }
  5544  
  5545  // ResolveReferences resolves references found inside Default objects.
  5546  func (m *Default) ResolveReferences(root string) (*yaml.Node, error) {
  5547  	errors := make([]error, 0)
  5548  	for _, item := range m.AdditionalProperties {
  5549  		if item != nil {
  5550  			_, err := item.ResolveReferences(root)
  5551  			if err != nil {
  5552  				errors = append(errors, err)
  5553  			}
  5554  		}
  5555  	}
  5556  	return nil, compiler.NewErrorGroupOrNil(errors)
  5557  }
  5558  
  5559  // ResolveReferences resolves references found inside Definitions objects.
  5560  func (m *Definitions) ResolveReferences(root string) (*yaml.Node, error) {
  5561  	errors := make([]error, 0)
  5562  	for _, item := range m.AdditionalProperties {
  5563  		if item != nil {
  5564  			_, err := item.ResolveReferences(root)
  5565  			if err != nil {
  5566  				errors = append(errors, err)
  5567  			}
  5568  		}
  5569  	}
  5570  	return nil, compiler.NewErrorGroupOrNil(errors)
  5571  }
  5572  
  5573  // ResolveReferences resolves references found inside Document objects.
  5574  func (m *Document) ResolveReferences(root string) (*yaml.Node, error) {
  5575  	errors := make([]error, 0)
  5576  	if m.Info != nil {
  5577  		_, err := m.Info.ResolveReferences(root)
  5578  		if err != nil {
  5579  			errors = append(errors, err)
  5580  		}
  5581  	}
  5582  	if m.Paths != nil {
  5583  		_, err := m.Paths.ResolveReferences(root)
  5584  		if err != nil {
  5585  			errors = append(errors, err)
  5586  		}
  5587  	}
  5588  	if m.Definitions != nil {
  5589  		_, err := m.Definitions.ResolveReferences(root)
  5590  		if err != nil {
  5591  			errors = append(errors, err)
  5592  		}
  5593  	}
  5594  	if m.Parameters != nil {
  5595  		_, err := m.Parameters.ResolveReferences(root)
  5596  		if err != nil {
  5597  			errors = append(errors, err)
  5598  		}
  5599  	}
  5600  	if m.Responses != nil {
  5601  		_, err := m.Responses.ResolveReferences(root)
  5602  		if err != nil {
  5603  			errors = append(errors, err)
  5604  		}
  5605  	}
  5606  	for _, item := range m.Security {
  5607  		if item != nil {
  5608  			_, err := item.ResolveReferences(root)
  5609  			if err != nil {
  5610  				errors = append(errors, err)
  5611  			}
  5612  		}
  5613  	}
  5614  	if m.SecurityDefinitions != nil {
  5615  		_, err := m.SecurityDefinitions.ResolveReferences(root)
  5616  		if err != nil {
  5617  			errors = append(errors, err)
  5618  		}
  5619  	}
  5620  	for _, item := range m.Tags {
  5621  		if item != nil {
  5622  			_, err := item.ResolveReferences(root)
  5623  			if err != nil {
  5624  				errors = append(errors, err)
  5625  			}
  5626  		}
  5627  	}
  5628  	if m.ExternalDocs != nil {
  5629  		_, err := m.ExternalDocs.ResolveReferences(root)
  5630  		if err != nil {
  5631  			errors = append(errors, err)
  5632  		}
  5633  	}
  5634  	for _, item := range m.VendorExtension {
  5635  		if item != nil {
  5636  			_, err := item.ResolveReferences(root)
  5637  			if err != nil {
  5638  				errors = append(errors, err)
  5639  			}
  5640  		}
  5641  	}
  5642  	return nil, compiler.NewErrorGroupOrNil(errors)
  5643  }
  5644  
  5645  // ResolveReferences resolves references found inside Examples objects.
  5646  func (m *Examples) ResolveReferences(root string) (*yaml.Node, error) {
  5647  	errors := make([]error, 0)
  5648  	for _, item := range m.AdditionalProperties {
  5649  		if item != nil {
  5650  			_, err := item.ResolveReferences(root)
  5651  			if err != nil {
  5652  				errors = append(errors, err)
  5653  			}
  5654  		}
  5655  	}
  5656  	return nil, compiler.NewErrorGroupOrNil(errors)
  5657  }
  5658  
  5659  // ResolveReferences resolves references found inside ExternalDocs objects.
  5660  func (m *ExternalDocs) ResolveReferences(root string) (*yaml.Node, error) {
  5661  	errors := make([]error, 0)
  5662  	for _, item := range m.VendorExtension {
  5663  		if item != nil {
  5664  			_, err := item.ResolveReferences(root)
  5665  			if err != nil {
  5666  				errors = append(errors, err)
  5667  			}
  5668  		}
  5669  	}
  5670  	return nil, compiler.NewErrorGroupOrNil(errors)
  5671  }
  5672  
  5673  // ResolveReferences resolves references found inside FileSchema objects.
  5674  func (m *FileSchema) ResolveReferences(root string) (*yaml.Node, error) {
  5675  	errors := make([]error, 0)
  5676  	if m.Default != nil {
  5677  		_, err := m.Default.ResolveReferences(root)
  5678  		if err != nil {
  5679  			errors = append(errors, err)
  5680  		}
  5681  	}
  5682  	if m.ExternalDocs != nil {
  5683  		_, err := m.ExternalDocs.ResolveReferences(root)
  5684  		if err != nil {
  5685  			errors = append(errors, err)
  5686  		}
  5687  	}
  5688  	if m.Example != nil {
  5689  		_, err := m.Example.ResolveReferences(root)
  5690  		if err != nil {
  5691  			errors = append(errors, err)
  5692  		}
  5693  	}
  5694  	for _, item := range m.VendorExtension {
  5695  		if item != nil {
  5696  			_, err := item.ResolveReferences(root)
  5697  			if err != nil {
  5698  				errors = append(errors, err)
  5699  			}
  5700  		}
  5701  	}
  5702  	return nil, compiler.NewErrorGroupOrNil(errors)
  5703  }
  5704  
  5705  // ResolveReferences resolves references found inside FormDataParameterSubSchema objects.
  5706  func (m *FormDataParameterSubSchema) ResolveReferences(root string) (*yaml.Node, error) {
  5707  	errors := make([]error, 0)
  5708  	if m.Items != nil {
  5709  		_, err := m.Items.ResolveReferences(root)
  5710  		if err != nil {
  5711  			errors = append(errors, err)
  5712  		}
  5713  	}
  5714  	if m.Default != nil {
  5715  		_, err := m.Default.ResolveReferences(root)
  5716  		if err != nil {
  5717  			errors = append(errors, err)
  5718  		}
  5719  	}
  5720  	for _, item := range m.Enum {
  5721  		if item != nil {
  5722  			_, err := item.ResolveReferences(root)
  5723  			if err != nil {
  5724  				errors = append(errors, err)
  5725  			}
  5726  		}
  5727  	}
  5728  	for _, item := range m.VendorExtension {
  5729  		if item != nil {
  5730  			_, err := item.ResolveReferences(root)
  5731  			if err != nil {
  5732  				errors = append(errors, err)
  5733  			}
  5734  		}
  5735  	}
  5736  	return nil, compiler.NewErrorGroupOrNil(errors)
  5737  }
  5738  
  5739  // ResolveReferences resolves references found inside Header objects.
  5740  func (m *Header) ResolveReferences(root string) (*yaml.Node, error) {
  5741  	errors := make([]error, 0)
  5742  	if m.Items != nil {
  5743  		_, err := m.Items.ResolveReferences(root)
  5744  		if err != nil {
  5745  			errors = append(errors, err)
  5746  		}
  5747  	}
  5748  	if m.Default != nil {
  5749  		_, err := m.Default.ResolveReferences(root)
  5750  		if err != nil {
  5751  			errors = append(errors, err)
  5752  		}
  5753  	}
  5754  	for _, item := range m.Enum {
  5755  		if item != nil {
  5756  			_, err := item.ResolveReferences(root)
  5757  			if err != nil {
  5758  				errors = append(errors, err)
  5759  			}
  5760  		}
  5761  	}
  5762  	for _, item := range m.VendorExtension {
  5763  		if item != nil {
  5764  			_, err := item.ResolveReferences(root)
  5765  			if err != nil {
  5766  				errors = append(errors, err)
  5767  			}
  5768  		}
  5769  	}
  5770  	return nil, compiler.NewErrorGroupOrNil(errors)
  5771  }
  5772  
  5773  // ResolveReferences resolves references found inside HeaderParameterSubSchema objects.
  5774  func (m *HeaderParameterSubSchema) ResolveReferences(root string) (*yaml.Node, error) {
  5775  	errors := make([]error, 0)
  5776  	if m.Items != nil {
  5777  		_, err := m.Items.ResolveReferences(root)
  5778  		if err != nil {
  5779  			errors = append(errors, err)
  5780  		}
  5781  	}
  5782  	if m.Default != nil {
  5783  		_, err := m.Default.ResolveReferences(root)
  5784  		if err != nil {
  5785  			errors = append(errors, err)
  5786  		}
  5787  	}
  5788  	for _, item := range m.Enum {
  5789  		if item != nil {
  5790  			_, err := item.ResolveReferences(root)
  5791  			if err != nil {
  5792  				errors = append(errors, err)
  5793  			}
  5794  		}
  5795  	}
  5796  	for _, item := range m.VendorExtension {
  5797  		if item != nil {
  5798  			_, err := item.ResolveReferences(root)
  5799  			if err != nil {
  5800  				errors = append(errors, err)
  5801  			}
  5802  		}
  5803  	}
  5804  	return nil, compiler.NewErrorGroupOrNil(errors)
  5805  }
  5806  
  5807  // ResolveReferences resolves references found inside Headers objects.
  5808  func (m *Headers) ResolveReferences(root string) (*yaml.Node, error) {
  5809  	errors := make([]error, 0)
  5810  	for _, item := range m.AdditionalProperties {
  5811  		if item != nil {
  5812  			_, err := item.ResolveReferences(root)
  5813  			if err != nil {
  5814  				errors = append(errors, err)
  5815  			}
  5816  		}
  5817  	}
  5818  	return nil, compiler.NewErrorGroupOrNil(errors)
  5819  }
  5820  
  5821  // ResolveReferences resolves references found inside Info objects.
  5822  func (m *Info) ResolveReferences(root string) (*yaml.Node, error) {
  5823  	errors := make([]error, 0)
  5824  	if m.Contact != nil {
  5825  		_, err := m.Contact.ResolveReferences(root)
  5826  		if err != nil {
  5827  			errors = append(errors, err)
  5828  		}
  5829  	}
  5830  	if m.License != nil {
  5831  		_, err := m.License.ResolveReferences(root)
  5832  		if err != nil {
  5833  			errors = append(errors, err)
  5834  		}
  5835  	}
  5836  	for _, item := range m.VendorExtension {
  5837  		if item != nil {
  5838  			_, err := item.ResolveReferences(root)
  5839  			if err != nil {
  5840  				errors = append(errors, err)
  5841  			}
  5842  		}
  5843  	}
  5844  	return nil, compiler.NewErrorGroupOrNil(errors)
  5845  }
  5846  
  5847  // ResolveReferences resolves references found inside ItemsItem objects.
  5848  func (m *ItemsItem) ResolveReferences(root string) (*yaml.Node, error) {
  5849  	errors := make([]error, 0)
  5850  	for _, item := range m.Schema {
  5851  		if item != nil {
  5852  			_, err := item.ResolveReferences(root)
  5853  			if err != nil {
  5854  				errors = append(errors, err)
  5855  			}
  5856  		}
  5857  	}
  5858  	return nil, compiler.NewErrorGroupOrNil(errors)
  5859  }
  5860  
  5861  // ResolveReferences resolves references found inside JsonReference objects.
  5862  func (m *JsonReference) ResolveReferences(root string) (*yaml.Node, error) {
  5863  	errors := make([]error, 0)
  5864  	if m.XRef != "" {
  5865  		info, err := compiler.ReadInfoForRef(root, m.XRef)
  5866  		if err != nil {
  5867  			return nil, err
  5868  		}
  5869  		if info != nil {
  5870  			replacement, err := NewJsonReference(info, nil)
  5871  			if err == nil {
  5872  				*m = *replacement
  5873  				return m.ResolveReferences(root)
  5874  			}
  5875  		}
  5876  		return info, nil
  5877  	}
  5878  	return nil, compiler.NewErrorGroupOrNil(errors)
  5879  }
  5880  
  5881  // ResolveReferences resolves references found inside License objects.
  5882  func (m *License) ResolveReferences(root string) (*yaml.Node, error) {
  5883  	errors := make([]error, 0)
  5884  	for _, item := range m.VendorExtension {
  5885  		if item != nil {
  5886  			_, err := item.ResolveReferences(root)
  5887  			if err != nil {
  5888  				errors = append(errors, err)
  5889  			}
  5890  		}
  5891  	}
  5892  	return nil, compiler.NewErrorGroupOrNil(errors)
  5893  }
  5894  
  5895  // ResolveReferences resolves references found inside NamedAny objects.
  5896  func (m *NamedAny) ResolveReferences(root string) (*yaml.Node, error) {
  5897  	errors := make([]error, 0)
  5898  	if m.Value != nil {
  5899  		_, err := m.Value.ResolveReferences(root)
  5900  		if err != nil {
  5901  			errors = append(errors, err)
  5902  		}
  5903  	}
  5904  	return nil, compiler.NewErrorGroupOrNil(errors)
  5905  }
  5906  
  5907  // ResolveReferences resolves references found inside NamedHeader objects.
  5908  func (m *NamedHeader) ResolveReferences(root string) (*yaml.Node, error) {
  5909  	errors := make([]error, 0)
  5910  	if m.Value != nil {
  5911  		_, err := m.Value.ResolveReferences(root)
  5912  		if err != nil {
  5913  			errors = append(errors, err)
  5914  		}
  5915  	}
  5916  	return nil, compiler.NewErrorGroupOrNil(errors)
  5917  }
  5918  
  5919  // ResolveReferences resolves references found inside NamedParameter objects.
  5920  func (m *NamedParameter) ResolveReferences(root string) (*yaml.Node, error) {
  5921  	errors := make([]error, 0)
  5922  	if m.Value != nil {
  5923  		_, err := m.Value.ResolveReferences(root)
  5924  		if err != nil {
  5925  			errors = append(errors, err)
  5926  		}
  5927  	}
  5928  	return nil, compiler.NewErrorGroupOrNil(errors)
  5929  }
  5930  
  5931  // ResolveReferences resolves references found inside NamedPathItem objects.
  5932  func (m *NamedPathItem) ResolveReferences(root string) (*yaml.Node, error) {
  5933  	errors := make([]error, 0)
  5934  	if m.Value != nil {
  5935  		_, err := m.Value.ResolveReferences(root)
  5936  		if err != nil {
  5937  			errors = append(errors, err)
  5938  		}
  5939  	}
  5940  	return nil, compiler.NewErrorGroupOrNil(errors)
  5941  }
  5942  
  5943  // ResolveReferences resolves references found inside NamedResponse objects.
  5944  func (m *NamedResponse) ResolveReferences(root string) (*yaml.Node, error) {
  5945  	errors := make([]error, 0)
  5946  	if m.Value != nil {
  5947  		_, err := m.Value.ResolveReferences(root)
  5948  		if err != nil {
  5949  			errors = append(errors, err)
  5950  		}
  5951  	}
  5952  	return nil, compiler.NewErrorGroupOrNil(errors)
  5953  }
  5954  
  5955  // ResolveReferences resolves references found inside NamedResponseValue objects.
  5956  func (m *NamedResponseValue) ResolveReferences(root string) (*yaml.Node, error) {
  5957  	errors := make([]error, 0)
  5958  	if m.Value != nil {
  5959  		_, err := m.Value.ResolveReferences(root)
  5960  		if err != nil {
  5961  			errors = append(errors, err)
  5962  		}
  5963  	}
  5964  	return nil, compiler.NewErrorGroupOrNil(errors)
  5965  }
  5966  
  5967  // ResolveReferences resolves references found inside NamedSchema objects.
  5968  func (m *NamedSchema) ResolveReferences(root string) (*yaml.Node, error) {
  5969  	errors := make([]error, 0)
  5970  	if m.Value != nil {
  5971  		_, err := m.Value.ResolveReferences(root)
  5972  		if err != nil {
  5973  			errors = append(errors, err)
  5974  		}
  5975  	}
  5976  	return nil, compiler.NewErrorGroupOrNil(errors)
  5977  }
  5978  
  5979  // ResolveReferences resolves references found inside NamedSecurityDefinitionsItem objects.
  5980  func (m *NamedSecurityDefinitionsItem) ResolveReferences(root string) (*yaml.Node, error) {
  5981  	errors := make([]error, 0)
  5982  	if m.Value != nil {
  5983  		_, err := m.Value.ResolveReferences(root)
  5984  		if err != nil {
  5985  			errors = append(errors, err)
  5986  		}
  5987  	}
  5988  	return nil, compiler.NewErrorGroupOrNil(errors)
  5989  }
  5990  
  5991  // ResolveReferences resolves references found inside NamedString objects.
  5992  func (m *NamedString) ResolveReferences(root string) (*yaml.Node, error) {
  5993  	errors := make([]error, 0)
  5994  	return nil, compiler.NewErrorGroupOrNil(errors)
  5995  }
  5996  
  5997  // ResolveReferences resolves references found inside NamedStringArray objects.
  5998  func (m *NamedStringArray) ResolveReferences(root string) (*yaml.Node, error) {
  5999  	errors := make([]error, 0)
  6000  	if m.Value != nil {
  6001  		_, err := m.Value.ResolveReferences(root)
  6002  		if err != nil {
  6003  			errors = append(errors, err)
  6004  		}
  6005  	}
  6006  	return nil, compiler.NewErrorGroupOrNil(errors)
  6007  }
  6008  
  6009  // ResolveReferences resolves references found inside NonBodyParameter objects.
  6010  func (m *NonBodyParameter) ResolveReferences(root string) (*yaml.Node, error) {
  6011  	errors := make([]error, 0)
  6012  	{
  6013  		p, ok := m.Oneof.(*NonBodyParameter_HeaderParameterSubSchema)
  6014  		if ok {
  6015  			_, err := p.HeaderParameterSubSchema.ResolveReferences(root)
  6016  			if err != nil {
  6017  				return nil, err
  6018  			}
  6019  		}
  6020  	}
  6021  	{
  6022  		p, ok := m.Oneof.(*NonBodyParameter_FormDataParameterSubSchema)
  6023  		if ok {
  6024  			_, err := p.FormDataParameterSubSchema.ResolveReferences(root)
  6025  			if err != nil {
  6026  				return nil, err
  6027  			}
  6028  		}
  6029  	}
  6030  	{
  6031  		p, ok := m.Oneof.(*NonBodyParameter_QueryParameterSubSchema)
  6032  		if ok {
  6033  			_, err := p.QueryParameterSubSchema.ResolveReferences(root)
  6034  			if err != nil {
  6035  				return nil, err
  6036  			}
  6037  		}
  6038  	}
  6039  	{
  6040  		p, ok := m.Oneof.(*NonBodyParameter_PathParameterSubSchema)
  6041  		if ok {
  6042  			_, err := p.PathParameterSubSchema.ResolveReferences(root)
  6043  			if err != nil {
  6044  				return nil, err
  6045  			}
  6046  		}
  6047  	}
  6048  	return nil, compiler.NewErrorGroupOrNil(errors)
  6049  }
  6050  
  6051  // ResolveReferences resolves references found inside Oauth2AccessCodeSecurity objects.
  6052  func (m *Oauth2AccessCodeSecurity) ResolveReferences(root string) (*yaml.Node, error) {
  6053  	errors := make([]error, 0)
  6054  	if m.Scopes != nil {
  6055  		_, err := m.Scopes.ResolveReferences(root)
  6056  		if err != nil {
  6057  			errors = append(errors, err)
  6058  		}
  6059  	}
  6060  	for _, item := range m.VendorExtension {
  6061  		if item != nil {
  6062  			_, err := item.ResolveReferences(root)
  6063  			if err != nil {
  6064  				errors = append(errors, err)
  6065  			}
  6066  		}
  6067  	}
  6068  	return nil, compiler.NewErrorGroupOrNil(errors)
  6069  }
  6070  
  6071  // ResolveReferences resolves references found inside Oauth2ApplicationSecurity objects.
  6072  func (m *Oauth2ApplicationSecurity) ResolveReferences(root string) (*yaml.Node, error) {
  6073  	errors := make([]error, 0)
  6074  	if m.Scopes != nil {
  6075  		_, err := m.Scopes.ResolveReferences(root)
  6076  		if err != nil {
  6077  			errors = append(errors, err)
  6078  		}
  6079  	}
  6080  	for _, item := range m.VendorExtension {
  6081  		if item != nil {
  6082  			_, err := item.ResolveReferences(root)
  6083  			if err != nil {
  6084  				errors = append(errors, err)
  6085  			}
  6086  		}
  6087  	}
  6088  	return nil, compiler.NewErrorGroupOrNil(errors)
  6089  }
  6090  
  6091  // ResolveReferences resolves references found inside Oauth2ImplicitSecurity objects.
  6092  func (m *Oauth2ImplicitSecurity) ResolveReferences(root string) (*yaml.Node, error) {
  6093  	errors := make([]error, 0)
  6094  	if m.Scopes != nil {
  6095  		_, err := m.Scopes.ResolveReferences(root)
  6096  		if err != nil {
  6097  			errors = append(errors, err)
  6098  		}
  6099  	}
  6100  	for _, item := range m.VendorExtension {
  6101  		if item != nil {
  6102  			_, err := item.ResolveReferences(root)
  6103  			if err != nil {
  6104  				errors = append(errors, err)
  6105  			}
  6106  		}
  6107  	}
  6108  	return nil, compiler.NewErrorGroupOrNil(errors)
  6109  }
  6110  
  6111  // ResolveReferences resolves references found inside Oauth2PasswordSecurity objects.
  6112  func (m *Oauth2PasswordSecurity) ResolveReferences(root string) (*yaml.Node, error) {
  6113  	errors := make([]error, 0)
  6114  	if m.Scopes != nil {
  6115  		_, err := m.Scopes.ResolveReferences(root)
  6116  		if err != nil {
  6117  			errors = append(errors, err)
  6118  		}
  6119  	}
  6120  	for _, item := range m.VendorExtension {
  6121  		if item != nil {
  6122  			_, err := item.ResolveReferences(root)
  6123  			if err != nil {
  6124  				errors = append(errors, err)
  6125  			}
  6126  		}
  6127  	}
  6128  	return nil, compiler.NewErrorGroupOrNil(errors)
  6129  }
  6130  
  6131  // ResolveReferences resolves references found inside Oauth2Scopes objects.
  6132  func (m *Oauth2Scopes) ResolveReferences(root string) (*yaml.Node, error) {
  6133  	errors := make([]error, 0)
  6134  	for _, item := range m.AdditionalProperties {
  6135  		if item != nil {
  6136  			_, err := item.ResolveReferences(root)
  6137  			if err != nil {
  6138  				errors = append(errors, err)
  6139  			}
  6140  		}
  6141  	}
  6142  	return nil, compiler.NewErrorGroupOrNil(errors)
  6143  }
  6144  
  6145  // ResolveReferences resolves references found inside Operation objects.
  6146  func (m *Operation) ResolveReferences(root string) (*yaml.Node, error) {
  6147  	errors := make([]error, 0)
  6148  	if m.ExternalDocs != nil {
  6149  		_, err := m.ExternalDocs.ResolveReferences(root)
  6150  		if err != nil {
  6151  			errors = append(errors, err)
  6152  		}
  6153  	}
  6154  	for _, item := range m.Parameters {
  6155  		if item != nil {
  6156  			_, err := item.ResolveReferences(root)
  6157  			if err != nil {
  6158  				errors = append(errors, err)
  6159  			}
  6160  		}
  6161  	}
  6162  	if m.Responses != nil {
  6163  		_, err := m.Responses.ResolveReferences(root)
  6164  		if err != nil {
  6165  			errors = append(errors, err)
  6166  		}
  6167  	}
  6168  	for _, item := range m.Security {
  6169  		if item != nil {
  6170  			_, err := item.ResolveReferences(root)
  6171  			if err != nil {
  6172  				errors = append(errors, err)
  6173  			}
  6174  		}
  6175  	}
  6176  	for _, item := range m.VendorExtension {
  6177  		if item != nil {
  6178  			_, err := item.ResolveReferences(root)
  6179  			if err != nil {
  6180  				errors = append(errors, err)
  6181  			}
  6182  		}
  6183  	}
  6184  	return nil, compiler.NewErrorGroupOrNil(errors)
  6185  }
  6186  
  6187  // ResolveReferences resolves references found inside Parameter objects.
  6188  func (m *Parameter) ResolveReferences(root string) (*yaml.Node, error) {
  6189  	errors := make([]error, 0)
  6190  	{
  6191  		p, ok := m.Oneof.(*Parameter_BodyParameter)
  6192  		if ok {
  6193  			_, err := p.BodyParameter.ResolveReferences(root)
  6194  			if err != nil {
  6195  				return nil, err
  6196  			}
  6197  		}
  6198  	}
  6199  	{
  6200  		p, ok := m.Oneof.(*Parameter_NonBodyParameter)
  6201  		if ok {
  6202  			_, err := p.NonBodyParameter.ResolveReferences(root)
  6203  			if err != nil {
  6204  				return nil, err
  6205  			}
  6206  		}
  6207  	}
  6208  	return nil, compiler.NewErrorGroupOrNil(errors)
  6209  }
  6210  
  6211  // ResolveReferences resolves references found inside ParameterDefinitions objects.
  6212  func (m *ParameterDefinitions) ResolveReferences(root string) (*yaml.Node, error) {
  6213  	errors := make([]error, 0)
  6214  	for _, item := range m.AdditionalProperties {
  6215  		if item != nil {
  6216  			_, err := item.ResolveReferences(root)
  6217  			if err != nil {
  6218  				errors = append(errors, err)
  6219  			}
  6220  		}
  6221  	}
  6222  	return nil, compiler.NewErrorGroupOrNil(errors)
  6223  }
  6224  
  6225  // ResolveReferences resolves references found inside ParametersItem objects.
  6226  func (m *ParametersItem) ResolveReferences(root string) (*yaml.Node, error) {
  6227  	errors := make([]error, 0)
  6228  	{
  6229  		p, ok := m.Oneof.(*ParametersItem_Parameter)
  6230  		if ok {
  6231  			_, err := p.Parameter.ResolveReferences(root)
  6232  			if err != nil {
  6233  				return nil, err
  6234  			}
  6235  		}
  6236  	}
  6237  	{
  6238  		p, ok := m.Oneof.(*ParametersItem_JsonReference)
  6239  		if ok {
  6240  			info, err := p.JsonReference.ResolveReferences(root)
  6241  			if err != nil {
  6242  				return nil, err
  6243  			} else if info != nil {
  6244  				n, err := NewParametersItem(info, nil)
  6245  				if err != nil {
  6246  					return nil, err
  6247  				} else if n != nil {
  6248  					*m = *n
  6249  					return nil, nil
  6250  				}
  6251  			}
  6252  		}
  6253  	}
  6254  	return nil, compiler.NewErrorGroupOrNil(errors)
  6255  }
  6256  
  6257  // ResolveReferences resolves references found inside PathItem objects.
  6258  func (m *PathItem) ResolveReferences(root string) (*yaml.Node, error) {
  6259  	errors := make([]error, 0)
  6260  	if m.XRef != "" {
  6261  		info, err := compiler.ReadInfoForRef(root, m.XRef)
  6262  		if err != nil {
  6263  			return nil, err
  6264  		}
  6265  		if info != nil {
  6266  			replacement, err := NewPathItem(info, nil)
  6267  			if err == nil {
  6268  				*m = *replacement
  6269  				return m.ResolveReferences(root)
  6270  			}
  6271  		}
  6272  		return info, nil
  6273  	}
  6274  	if m.Get != nil {
  6275  		_, err := m.Get.ResolveReferences(root)
  6276  		if err != nil {
  6277  			errors = append(errors, err)
  6278  		}
  6279  	}
  6280  	if m.Put != nil {
  6281  		_, err := m.Put.ResolveReferences(root)
  6282  		if err != nil {
  6283  			errors = append(errors, err)
  6284  		}
  6285  	}
  6286  	if m.Post != nil {
  6287  		_, err := m.Post.ResolveReferences(root)
  6288  		if err != nil {
  6289  			errors = append(errors, err)
  6290  		}
  6291  	}
  6292  	if m.Delete != nil {
  6293  		_, err := m.Delete.ResolveReferences(root)
  6294  		if err != nil {
  6295  			errors = append(errors, err)
  6296  		}
  6297  	}
  6298  	if m.Options != nil {
  6299  		_, err := m.Options.ResolveReferences(root)
  6300  		if err != nil {
  6301  			errors = append(errors, err)
  6302  		}
  6303  	}
  6304  	if m.Head != nil {
  6305  		_, err := m.Head.ResolveReferences(root)
  6306  		if err != nil {
  6307  			errors = append(errors, err)
  6308  		}
  6309  	}
  6310  	if m.Patch != nil {
  6311  		_, err := m.Patch.ResolveReferences(root)
  6312  		if err != nil {
  6313  			errors = append(errors, err)
  6314  		}
  6315  	}
  6316  	for _, item := range m.Parameters {
  6317  		if item != nil {
  6318  			_, err := item.ResolveReferences(root)
  6319  			if err != nil {
  6320  				errors = append(errors, err)
  6321  			}
  6322  		}
  6323  	}
  6324  	for _, item := range m.VendorExtension {
  6325  		if item != nil {
  6326  			_, err := item.ResolveReferences(root)
  6327  			if err != nil {
  6328  				errors = append(errors, err)
  6329  			}
  6330  		}
  6331  	}
  6332  	return nil, compiler.NewErrorGroupOrNil(errors)
  6333  }
  6334  
  6335  // ResolveReferences resolves references found inside PathParameterSubSchema objects.
  6336  func (m *PathParameterSubSchema) ResolveReferences(root string) (*yaml.Node, error) {
  6337  	errors := make([]error, 0)
  6338  	if m.Items != nil {
  6339  		_, err := m.Items.ResolveReferences(root)
  6340  		if err != nil {
  6341  			errors = append(errors, err)
  6342  		}
  6343  	}
  6344  	if m.Default != nil {
  6345  		_, err := m.Default.ResolveReferences(root)
  6346  		if err != nil {
  6347  			errors = append(errors, err)
  6348  		}
  6349  	}
  6350  	for _, item := range m.Enum {
  6351  		if item != nil {
  6352  			_, err := item.ResolveReferences(root)
  6353  			if err != nil {
  6354  				errors = append(errors, err)
  6355  			}
  6356  		}
  6357  	}
  6358  	for _, item := range m.VendorExtension {
  6359  		if item != nil {
  6360  			_, err := item.ResolveReferences(root)
  6361  			if err != nil {
  6362  				errors = append(errors, err)
  6363  			}
  6364  		}
  6365  	}
  6366  	return nil, compiler.NewErrorGroupOrNil(errors)
  6367  }
  6368  
  6369  // ResolveReferences resolves references found inside Paths objects.
  6370  func (m *Paths) ResolveReferences(root string) (*yaml.Node, error) {
  6371  	errors := make([]error, 0)
  6372  	for _, item := range m.VendorExtension {
  6373  		if item != nil {
  6374  			_, err := item.ResolveReferences(root)
  6375  			if err != nil {
  6376  				errors = append(errors, err)
  6377  			}
  6378  		}
  6379  	}
  6380  	for _, item := range m.Path {
  6381  		if item != nil {
  6382  			_, err := item.ResolveReferences(root)
  6383  			if err != nil {
  6384  				errors = append(errors, err)
  6385  			}
  6386  		}
  6387  	}
  6388  	return nil, compiler.NewErrorGroupOrNil(errors)
  6389  }
  6390  
  6391  // ResolveReferences resolves references found inside PrimitivesItems objects.
  6392  func (m *PrimitivesItems) ResolveReferences(root string) (*yaml.Node, error) {
  6393  	errors := make([]error, 0)
  6394  	if m.Items != nil {
  6395  		_, err := m.Items.ResolveReferences(root)
  6396  		if err != nil {
  6397  			errors = append(errors, err)
  6398  		}
  6399  	}
  6400  	if m.Default != nil {
  6401  		_, err := m.Default.ResolveReferences(root)
  6402  		if err != nil {
  6403  			errors = append(errors, err)
  6404  		}
  6405  	}
  6406  	for _, item := range m.Enum {
  6407  		if item != nil {
  6408  			_, err := item.ResolveReferences(root)
  6409  			if err != nil {
  6410  				errors = append(errors, err)
  6411  			}
  6412  		}
  6413  	}
  6414  	for _, item := range m.VendorExtension {
  6415  		if item != nil {
  6416  			_, err := item.ResolveReferences(root)
  6417  			if err != nil {
  6418  				errors = append(errors, err)
  6419  			}
  6420  		}
  6421  	}
  6422  	return nil, compiler.NewErrorGroupOrNil(errors)
  6423  }
  6424  
  6425  // ResolveReferences resolves references found inside Properties objects.
  6426  func (m *Properties) ResolveReferences(root string) (*yaml.Node, error) {
  6427  	errors := make([]error, 0)
  6428  	for _, item := range m.AdditionalProperties {
  6429  		if item != nil {
  6430  			_, err := item.ResolveReferences(root)
  6431  			if err != nil {
  6432  				errors = append(errors, err)
  6433  			}
  6434  		}
  6435  	}
  6436  	return nil, compiler.NewErrorGroupOrNil(errors)
  6437  }
  6438  
  6439  // ResolveReferences resolves references found inside QueryParameterSubSchema objects.
  6440  func (m *QueryParameterSubSchema) ResolveReferences(root string) (*yaml.Node, error) {
  6441  	errors := make([]error, 0)
  6442  	if m.Items != nil {
  6443  		_, err := m.Items.ResolveReferences(root)
  6444  		if err != nil {
  6445  			errors = append(errors, err)
  6446  		}
  6447  	}
  6448  	if m.Default != nil {
  6449  		_, err := m.Default.ResolveReferences(root)
  6450  		if err != nil {
  6451  			errors = append(errors, err)
  6452  		}
  6453  	}
  6454  	for _, item := range m.Enum {
  6455  		if item != nil {
  6456  			_, err := item.ResolveReferences(root)
  6457  			if err != nil {
  6458  				errors = append(errors, err)
  6459  			}
  6460  		}
  6461  	}
  6462  	for _, item := range m.VendorExtension {
  6463  		if item != nil {
  6464  			_, err := item.ResolveReferences(root)
  6465  			if err != nil {
  6466  				errors = append(errors, err)
  6467  			}
  6468  		}
  6469  	}
  6470  	return nil, compiler.NewErrorGroupOrNil(errors)
  6471  }
  6472  
  6473  // ResolveReferences resolves references found inside Response objects.
  6474  func (m *Response) ResolveReferences(root string) (*yaml.Node, error) {
  6475  	errors := make([]error, 0)
  6476  	if m.Schema != nil {
  6477  		_, err := m.Schema.ResolveReferences(root)
  6478  		if err != nil {
  6479  			errors = append(errors, err)
  6480  		}
  6481  	}
  6482  	if m.Headers != nil {
  6483  		_, err := m.Headers.ResolveReferences(root)
  6484  		if err != nil {
  6485  			errors = append(errors, err)
  6486  		}
  6487  	}
  6488  	if m.Examples != nil {
  6489  		_, err := m.Examples.ResolveReferences(root)
  6490  		if err != nil {
  6491  			errors = append(errors, err)
  6492  		}
  6493  	}
  6494  	for _, item := range m.VendorExtension {
  6495  		if item != nil {
  6496  			_, err := item.ResolveReferences(root)
  6497  			if err != nil {
  6498  				errors = append(errors, err)
  6499  			}
  6500  		}
  6501  	}
  6502  	return nil, compiler.NewErrorGroupOrNil(errors)
  6503  }
  6504  
  6505  // ResolveReferences resolves references found inside ResponseDefinitions objects.
  6506  func (m *ResponseDefinitions) ResolveReferences(root string) (*yaml.Node, error) {
  6507  	errors := make([]error, 0)
  6508  	for _, item := range m.AdditionalProperties {
  6509  		if item != nil {
  6510  			_, err := item.ResolveReferences(root)
  6511  			if err != nil {
  6512  				errors = append(errors, err)
  6513  			}
  6514  		}
  6515  	}
  6516  	return nil, compiler.NewErrorGroupOrNil(errors)
  6517  }
  6518  
  6519  // ResolveReferences resolves references found inside ResponseValue objects.
  6520  func (m *ResponseValue) ResolveReferences(root string) (*yaml.Node, error) {
  6521  	errors := make([]error, 0)
  6522  	{
  6523  		p, ok := m.Oneof.(*ResponseValue_Response)
  6524  		if ok {
  6525  			_, err := p.Response.ResolveReferences(root)
  6526  			if err != nil {
  6527  				return nil, err
  6528  			}
  6529  		}
  6530  	}
  6531  	{
  6532  		p, ok := m.Oneof.(*ResponseValue_JsonReference)
  6533  		if ok {
  6534  			info, err := p.JsonReference.ResolveReferences(root)
  6535  			if err != nil {
  6536  				return nil, err
  6537  			} else if info != nil {
  6538  				n, err := NewResponseValue(info, nil)
  6539  				if err != nil {
  6540  					return nil, err
  6541  				} else if n != nil {
  6542  					*m = *n
  6543  					return nil, nil
  6544  				}
  6545  			}
  6546  		}
  6547  	}
  6548  	return nil, compiler.NewErrorGroupOrNil(errors)
  6549  }
  6550  
  6551  // ResolveReferences resolves references found inside Responses objects.
  6552  func (m *Responses) ResolveReferences(root string) (*yaml.Node, error) {
  6553  	errors := make([]error, 0)
  6554  	for _, item := range m.ResponseCode {
  6555  		if item != nil {
  6556  			_, err := item.ResolveReferences(root)
  6557  			if err != nil {
  6558  				errors = append(errors, err)
  6559  			}
  6560  		}
  6561  	}
  6562  	for _, item := range m.VendorExtension {
  6563  		if item != nil {
  6564  			_, err := item.ResolveReferences(root)
  6565  			if err != nil {
  6566  				errors = append(errors, err)
  6567  			}
  6568  		}
  6569  	}
  6570  	return nil, compiler.NewErrorGroupOrNil(errors)
  6571  }
  6572  
  6573  // ResolveReferences resolves references found inside Schema objects.
  6574  func (m *Schema) ResolveReferences(root string) (*yaml.Node, error) {
  6575  	errors := make([]error, 0)
  6576  	if m.XRef != "" {
  6577  		info, err := compiler.ReadInfoForRef(root, m.XRef)
  6578  		if err != nil {
  6579  			return nil, err
  6580  		}
  6581  		if info != nil {
  6582  			replacement, err := NewSchema(info, nil)
  6583  			if err == nil {
  6584  				*m = *replacement
  6585  				return m.ResolveReferences(root)
  6586  			}
  6587  		}
  6588  		return info, nil
  6589  	}
  6590  	if m.Default != nil {
  6591  		_, err := m.Default.ResolveReferences(root)
  6592  		if err != nil {
  6593  			errors = append(errors, err)
  6594  		}
  6595  	}
  6596  	for _, item := range m.Enum {
  6597  		if item != nil {
  6598  			_, err := item.ResolveReferences(root)
  6599  			if err != nil {
  6600  				errors = append(errors, err)
  6601  			}
  6602  		}
  6603  	}
  6604  	if m.AdditionalProperties != nil {
  6605  		_, err := m.AdditionalProperties.ResolveReferences(root)
  6606  		if err != nil {
  6607  			errors = append(errors, err)
  6608  		}
  6609  	}
  6610  	if m.Type != nil {
  6611  		_, err := m.Type.ResolveReferences(root)
  6612  		if err != nil {
  6613  			errors = append(errors, err)
  6614  		}
  6615  	}
  6616  	if m.Items != nil {
  6617  		_, err := m.Items.ResolveReferences(root)
  6618  		if err != nil {
  6619  			errors = append(errors, err)
  6620  		}
  6621  	}
  6622  	for _, item := range m.AllOf {
  6623  		if item != nil {
  6624  			_, err := item.ResolveReferences(root)
  6625  			if err != nil {
  6626  				errors = append(errors, err)
  6627  			}
  6628  		}
  6629  	}
  6630  	if m.Properties != nil {
  6631  		_, err := m.Properties.ResolveReferences(root)
  6632  		if err != nil {
  6633  			errors = append(errors, err)
  6634  		}
  6635  	}
  6636  	if m.Xml != nil {
  6637  		_, err := m.Xml.ResolveReferences(root)
  6638  		if err != nil {
  6639  			errors = append(errors, err)
  6640  		}
  6641  	}
  6642  	if m.ExternalDocs != nil {
  6643  		_, err := m.ExternalDocs.ResolveReferences(root)
  6644  		if err != nil {
  6645  			errors = append(errors, err)
  6646  		}
  6647  	}
  6648  	if m.Example != nil {
  6649  		_, err := m.Example.ResolveReferences(root)
  6650  		if err != nil {
  6651  			errors = append(errors, err)
  6652  		}
  6653  	}
  6654  	for _, item := range m.VendorExtension {
  6655  		if item != nil {
  6656  			_, err := item.ResolveReferences(root)
  6657  			if err != nil {
  6658  				errors = append(errors, err)
  6659  			}
  6660  		}
  6661  	}
  6662  	return nil, compiler.NewErrorGroupOrNil(errors)
  6663  }
  6664  
  6665  // ResolveReferences resolves references found inside SchemaItem objects.
  6666  func (m *SchemaItem) ResolveReferences(root string) (*yaml.Node, error) {
  6667  	errors := make([]error, 0)
  6668  	{
  6669  		p, ok := m.Oneof.(*SchemaItem_Schema)
  6670  		if ok {
  6671  			_, err := p.Schema.ResolveReferences(root)
  6672  			if err != nil {
  6673  				return nil, err
  6674  			}
  6675  		}
  6676  	}
  6677  	{
  6678  		p, ok := m.Oneof.(*SchemaItem_FileSchema)
  6679  		if ok {
  6680  			_, err := p.FileSchema.ResolveReferences(root)
  6681  			if err != nil {
  6682  				return nil, err
  6683  			}
  6684  		}
  6685  	}
  6686  	return nil, compiler.NewErrorGroupOrNil(errors)
  6687  }
  6688  
  6689  // ResolveReferences resolves references found inside SecurityDefinitions objects.
  6690  func (m *SecurityDefinitions) ResolveReferences(root string) (*yaml.Node, error) {
  6691  	errors := make([]error, 0)
  6692  	for _, item := range m.AdditionalProperties {
  6693  		if item != nil {
  6694  			_, err := item.ResolveReferences(root)
  6695  			if err != nil {
  6696  				errors = append(errors, err)
  6697  			}
  6698  		}
  6699  	}
  6700  	return nil, compiler.NewErrorGroupOrNil(errors)
  6701  }
  6702  
  6703  // ResolveReferences resolves references found inside SecurityDefinitionsItem objects.
  6704  func (m *SecurityDefinitionsItem) ResolveReferences(root string) (*yaml.Node, error) {
  6705  	errors := make([]error, 0)
  6706  	{
  6707  		p, ok := m.Oneof.(*SecurityDefinitionsItem_BasicAuthenticationSecurity)
  6708  		if ok {
  6709  			_, err := p.BasicAuthenticationSecurity.ResolveReferences(root)
  6710  			if err != nil {
  6711  				return nil, err
  6712  			}
  6713  		}
  6714  	}
  6715  	{
  6716  		p, ok := m.Oneof.(*SecurityDefinitionsItem_ApiKeySecurity)
  6717  		if ok {
  6718  			_, err := p.ApiKeySecurity.ResolveReferences(root)
  6719  			if err != nil {
  6720  				return nil, err
  6721  			}
  6722  		}
  6723  	}
  6724  	{
  6725  		p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2ImplicitSecurity)
  6726  		if ok {
  6727  			_, err := p.Oauth2ImplicitSecurity.ResolveReferences(root)
  6728  			if err != nil {
  6729  				return nil, err
  6730  			}
  6731  		}
  6732  	}
  6733  	{
  6734  		p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2PasswordSecurity)
  6735  		if ok {
  6736  			_, err := p.Oauth2PasswordSecurity.ResolveReferences(root)
  6737  			if err != nil {
  6738  				return nil, err
  6739  			}
  6740  		}
  6741  	}
  6742  	{
  6743  		p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2ApplicationSecurity)
  6744  		if ok {
  6745  			_, err := p.Oauth2ApplicationSecurity.ResolveReferences(root)
  6746  			if err != nil {
  6747  				return nil, err
  6748  			}
  6749  		}
  6750  	}
  6751  	{
  6752  		p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2AccessCodeSecurity)
  6753  		if ok {
  6754  			_, err := p.Oauth2AccessCodeSecurity.ResolveReferences(root)
  6755  			if err != nil {
  6756  				return nil, err
  6757  			}
  6758  		}
  6759  	}
  6760  	return nil, compiler.NewErrorGroupOrNil(errors)
  6761  }
  6762  
  6763  // ResolveReferences resolves references found inside SecurityRequirement objects.
  6764  func (m *SecurityRequirement) ResolveReferences(root string) (*yaml.Node, error) {
  6765  	errors := make([]error, 0)
  6766  	for _, item := range m.AdditionalProperties {
  6767  		if item != nil {
  6768  			_, err := item.ResolveReferences(root)
  6769  			if err != nil {
  6770  				errors = append(errors, err)
  6771  			}
  6772  		}
  6773  	}
  6774  	return nil, compiler.NewErrorGroupOrNil(errors)
  6775  }
  6776  
  6777  // ResolveReferences resolves references found inside StringArray objects.
  6778  func (m *StringArray) ResolveReferences(root string) (*yaml.Node, error) {
  6779  	errors := make([]error, 0)
  6780  	return nil, compiler.NewErrorGroupOrNil(errors)
  6781  }
  6782  
  6783  // ResolveReferences resolves references found inside Tag objects.
  6784  func (m *Tag) ResolveReferences(root string) (*yaml.Node, error) {
  6785  	errors := make([]error, 0)
  6786  	if m.ExternalDocs != nil {
  6787  		_, err := m.ExternalDocs.ResolveReferences(root)
  6788  		if err != nil {
  6789  			errors = append(errors, err)
  6790  		}
  6791  	}
  6792  	for _, item := range m.VendorExtension {
  6793  		if item != nil {
  6794  			_, err := item.ResolveReferences(root)
  6795  			if err != nil {
  6796  				errors = append(errors, err)
  6797  			}
  6798  		}
  6799  	}
  6800  	return nil, compiler.NewErrorGroupOrNil(errors)
  6801  }
  6802  
  6803  // ResolveReferences resolves references found inside TypeItem objects.
  6804  func (m *TypeItem) ResolveReferences(root string) (*yaml.Node, error) {
  6805  	errors := make([]error, 0)
  6806  	return nil, compiler.NewErrorGroupOrNil(errors)
  6807  }
  6808  
  6809  // ResolveReferences resolves references found inside VendorExtension objects.
  6810  func (m *VendorExtension) ResolveReferences(root string) (*yaml.Node, error) {
  6811  	errors := make([]error, 0)
  6812  	for _, item := range m.AdditionalProperties {
  6813  		if item != nil {
  6814  			_, err := item.ResolveReferences(root)
  6815  			if err != nil {
  6816  				errors = append(errors, err)
  6817  			}
  6818  		}
  6819  	}
  6820  	return nil, compiler.NewErrorGroupOrNil(errors)
  6821  }
  6822  
  6823  // ResolveReferences resolves references found inside Xml objects.
  6824  func (m *Xml) ResolveReferences(root string) (*yaml.Node, error) {
  6825  	errors := make([]error, 0)
  6826  	for _, item := range m.VendorExtension {
  6827  		if item != nil {
  6828  			_, err := item.ResolveReferences(root)
  6829  			if err != nil {
  6830  				errors = append(errors, err)
  6831  			}
  6832  		}
  6833  	}
  6834  	return nil, compiler.NewErrorGroupOrNil(errors)
  6835  }
  6836  
  6837  // ToRawInfo returns a description of AdditionalPropertiesItem suitable for JSON or YAML export.
  6838  func (m *AdditionalPropertiesItem) ToRawInfo() *yaml.Node {
  6839  	// ONE OF WRAPPER
  6840  	// AdditionalPropertiesItem
  6841  	// {Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  6842  	v0 := m.GetSchema()
  6843  	if v0 != nil {
  6844  		return v0.ToRawInfo()
  6845  	}
  6846  	// {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  6847  	if v1, ok := m.GetOneof().(*AdditionalPropertiesItem_Boolean); ok {
  6848  		return compiler.NewScalarNodeForBool(v1.Boolean)
  6849  	}
  6850  	return compiler.NewNullNode()
  6851  }
  6852  
  6853  // ToRawInfo returns a description of Any suitable for JSON or YAML export.
  6854  func (m *Any) ToRawInfo() *yaml.Node {
  6855  	var err error
  6856  	var node yaml.Node
  6857  	err = yaml.Unmarshal([]byte(m.Yaml), &node)
  6858  	if err == nil {
  6859  		if node.Kind == yaml.DocumentNode {
  6860  			return node.Content[0]
  6861  		}
  6862  		return &node
  6863  	}
  6864  	return compiler.NewNullNode()
  6865  }
  6866  
  6867  // ToRawInfo returns a description of ApiKeySecurity suitable for JSON or YAML export.
  6868  func (m *ApiKeySecurity) ToRawInfo() *yaml.Node {
  6869  	info := compiler.NewMappingNode()
  6870  	if m == nil {
  6871  		return info
  6872  	}
  6873  	// always include this required field.
  6874  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  6875  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  6876  	// always include this required field.
  6877  	info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  6878  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  6879  	// always include this required field.
  6880  	info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  6881  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  6882  	if m.Description != "" {
  6883  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  6884  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  6885  	}
  6886  	if m.VendorExtension != nil {
  6887  		for _, item := range m.VendorExtension {
  6888  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  6889  			info.Content = append(info.Content, item.Value.ToRawInfo())
  6890  		}
  6891  	}
  6892  	return info
  6893  }
  6894  
  6895  // ToRawInfo returns a description of BasicAuthenticationSecurity suitable for JSON or YAML export.
  6896  func (m *BasicAuthenticationSecurity) ToRawInfo() *yaml.Node {
  6897  	info := compiler.NewMappingNode()
  6898  	if m == nil {
  6899  		return info
  6900  	}
  6901  	// always include this required field.
  6902  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  6903  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  6904  	if m.Description != "" {
  6905  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  6906  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  6907  	}
  6908  	if m.VendorExtension != nil {
  6909  		for _, item := range m.VendorExtension {
  6910  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  6911  			info.Content = append(info.Content, item.Value.ToRawInfo())
  6912  		}
  6913  	}
  6914  	return info
  6915  }
  6916  
  6917  // ToRawInfo returns a description of BodyParameter suitable for JSON or YAML export.
  6918  func (m *BodyParameter) ToRawInfo() *yaml.Node {
  6919  	info := compiler.NewMappingNode()
  6920  	if m == nil {
  6921  		return info
  6922  	}
  6923  	if m.Description != "" {
  6924  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  6925  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  6926  	}
  6927  	// always include this required field.
  6928  	info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  6929  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  6930  	// always include this required field.
  6931  	info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  6932  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  6933  	if m.Required != false {
  6934  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  6935  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Required))
  6936  	}
  6937  	// always include this required field.
  6938  	info.Content = append(info.Content, compiler.NewScalarNodeForString("schema"))
  6939  	info.Content = append(info.Content, m.Schema.ToRawInfo())
  6940  	if m.VendorExtension != nil {
  6941  		for _, item := range m.VendorExtension {
  6942  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  6943  			info.Content = append(info.Content, item.Value.ToRawInfo())
  6944  		}
  6945  	}
  6946  	return info
  6947  }
  6948  
  6949  // ToRawInfo returns a description of Contact suitable for JSON or YAML export.
  6950  func (m *Contact) ToRawInfo() *yaml.Node {
  6951  	info := compiler.NewMappingNode()
  6952  	if m == nil {
  6953  		return info
  6954  	}
  6955  	if m.Name != "" {
  6956  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  6957  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  6958  	}
  6959  	if m.Url != "" {
  6960  		info.Content = append(info.Content, compiler.NewScalarNodeForString("url"))
  6961  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Url))
  6962  	}
  6963  	if m.Email != "" {
  6964  		info.Content = append(info.Content, compiler.NewScalarNodeForString("email"))
  6965  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Email))
  6966  	}
  6967  	if m.VendorExtension != nil {
  6968  		for _, item := range m.VendorExtension {
  6969  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  6970  			info.Content = append(info.Content, item.Value.ToRawInfo())
  6971  		}
  6972  	}
  6973  	return info
  6974  }
  6975  
  6976  // ToRawInfo returns a description of Default suitable for JSON or YAML export.
  6977  func (m *Default) ToRawInfo() *yaml.Node {
  6978  	info := compiler.NewMappingNode()
  6979  	if m == nil {
  6980  		return info
  6981  	}
  6982  	if m.AdditionalProperties != nil {
  6983  		for _, item := range m.AdditionalProperties {
  6984  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  6985  			info.Content = append(info.Content, item.Value.ToRawInfo())
  6986  		}
  6987  	}
  6988  	return info
  6989  }
  6990  
  6991  // ToRawInfo returns a description of Definitions suitable for JSON or YAML export.
  6992  func (m *Definitions) ToRawInfo() *yaml.Node {
  6993  	info := compiler.NewMappingNode()
  6994  	if m == nil {
  6995  		return info
  6996  	}
  6997  	if m.AdditionalProperties != nil {
  6998  		for _, item := range m.AdditionalProperties {
  6999  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7000  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7001  		}
  7002  	}
  7003  	return info
  7004  }
  7005  
  7006  // ToRawInfo returns a description of Document suitable for JSON or YAML export.
  7007  func (m *Document) ToRawInfo() *yaml.Node {
  7008  	info := compiler.NewMappingNode()
  7009  	if m == nil {
  7010  		return info
  7011  	}
  7012  	// always include this required field.
  7013  	info.Content = append(info.Content, compiler.NewScalarNodeForString("swagger"))
  7014  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Swagger))
  7015  	// always include this required field.
  7016  	info.Content = append(info.Content, compiler.NewScalarNodeForString("info"))
  7017  	info.Content = append(info.Content, m.Info.ToRawInfo())
  7018  	if m.Host != "" {
  7019  		info.Content = append(info.Content, compiler.NewScalarNodeForString("host"))
  7020  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Host))
  7021  	}
  7022  	if m.BasePath != "" {
  7023  		info.Content = append(info.Content, compiler.NewScalarNodeForString("basePath"))
  7024  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.BasePath))
  7025  	}
  7026  	if len(m.Schemes) != 0 {
  7027  		info.Content = append(info.Content, compiler.NewScalarNodeForString("schemes"))
  7028  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Schemes))
  7029  	}
  7030  	if len(m.Consumes) != 0 {
  7031  		info.Content = append(info.Content, compiler.NewScalarNodeForString("consumes"))
  7032  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Consumes))
  7033  	}
  7034  	if len(m.Produces) != 0 {
  7035  		info.Content = append(info.Content, compiler.NewScalarNodeForString("produces"))
  7036  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Produces))
  7037  	}
  7038  	// always include this required field.
  7039  	info.Content = append(info.Content, compiler.NewScalarNodeForString("paths"))
  7040  	info.Content = append(info.Content, m.Paths.ToRawInfo())
  7041  	if m.Definitions != nil {
  7042  		info.Content = append(info.Content, compiler.NewScalarNodeForString("definitions"))
  7043  		info.Content = append(info.Content, m.Definitions.ToRawInfo())
  7044  	}
  7045  	if m.Parameters != nil {
  7046  		info.Content = append(info.Content, compiler.NewScalarNodeForString("parameters"))
  7047  		info.Content = append(info.Content, m.Parameters.ToRawInfo())
  7048  	}
  7049  	if m.Responses != nil {
  7050  		info.Content = append(info.Content, compiler.NewScalarNodeForString("responses"))
  7051  		info.Content = append(info.Content, m.Responses.ToRawInfo())
  7052  	}
  7053  	if len(m.Security) != 0 {
  7054  		items := compiler.NewSequenceNode()
  7055  		for _, item := range m.Security {
  7056  			items.Content = append(items.Content, item.ToRawInfo())
  7057  		}
  7058  		info.Content = append(info.Content, compiler.NewScalarNodeForString("security"))
  7059  		info.Content = append(info.Content, items)
  7060  	}
  7061  	if m.SecurityDefinitions != nil {
  7062  		info.Content = append(info.Content, compiler.NewScalarNodeForString("securityDefinitions"))
  7063  		info.Content = append(info.Content, m.SecurityDefinitions.ToRawInfo())
  7064  	}
  7065  	if len(m.Tags) != 0 {
  7066  		items := compiler.NewSequenceNode()
  7067  		for _, item := range m.Tags {
  7068  			items.Content = append(items.Content, item.ToRawInfo())
  7069  		}
  7070  		info.Content = append(info.Content, compiler.NewScalarNodeForString("tags"))
  7071  		info.Content = append(info.Content, items)
  7072  	}
  7073  	if m.ExternalDocs != nil {
  7074  		info.Content = append(info.Content, compiler.NewScalarNodeForString("externalDocs"))
  7075  		info.Content = append(info.Content, m.ExternalDocs.ToRawInfo())
  7076  	}
  7077  	if m.VendorExtension != nil {
  7078  		for _, item := range m.VendorExtension {
  7079  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7080  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7081  		}
  7082  	}
  7083  	return info
  7084  }
  7085  
  7086  // ToRawInfo returns a description of Examples suitable for JSON or YAML export.
  7087  func (m *Examples) ToRawInfo() *yaml.Node {
  7088  	info := compiler.NewMappingNode()
  7089  	if m == nil {
  7090  		return info
  7091  	}
  7092  	if m.AdditionalProperties != nil {
  7093  		for _, item := range m.AdditionalProperties {
  7094  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7095  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7096  		}
  7097  	}
  7098  	return info
  7099  }
  7100  
  7101  // ToRawInfo returns a description of ExternalDocs suitable for JSON or YAML export.
  7102  func (m *ExternalDocs) ToRawInfo() *yaml.Node {
  7103  	info := compiler.NewMappingNode()
  7104  	if m == nil {
  7105  		return info
  7106  	}
  7107  	if m.Description != "" {
  7108  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7109  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7110  	}
  7111  	// always include this required field.
  7112  	info.Content = append(info.Content, compiler.NewScalarNodeForString("url"))
  7113  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Url))
  7114  	if m.VendorExtension != nil {
  7115  		for _, item := range m.VendorExtension {
  7116  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7117  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7118  		}
  7119  	}
  7120  	return info
  7121  }
  7122  
  7123  // ToRawInfo returns a description of FileSchema suitable for JSON or YAML export.
  7124  func (m *FileSchema) ToRawInfo() *yaml.Node {
  7125  	info := compiler.NewMappingNode()
  7126  	if m == nil {
  7127  		return info
  7128  	}
  7129  	if m.Format != "" {
  7130  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  7131  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  7132  	}
  7133  	if m.Title != "" {
  7134  		info.Content = append(info.Content, compiler.NewScalarNodeForString("title"))
  7135  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Title))
  7136  	}
  7137  	if m.Description != "" {
  7138  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7139  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7140  	}
  7141  	if m.Default != nil {
  7142  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  7143  		info.Content = append(info.Content, m.Default.ToRawInfo())
  7144  	}
  7145  	if len(m.Required) != 0 {
  7146  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  7147  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Required))
  7148  	}
  7149  	// always include this required field.
  7150  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7151  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7152  	if m.ReadOnly != false {
  7153  		info.Content = append(info.Content, compiler.NewScalarNodeForString("readOnly"))
  7154  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ReadOnly))
  7155  	}
  7156  	if m.ExternalDocs != nil {
  7157  		info.Content = append(info.Content, compiler.NewScalarNodeForString("externalDocs"))
  7158  		info.Content = append(info.Content, m.ExternalDocs.ToRawInfo())
  7159  	}
  7160  	if m.Example != nil {
  7161  		info.Content = append(info.Content, compiler.NewScalarNodeForString("example"))
  7162  		info.Content = append(info.Content, m.Example.ToRawInfo())
  7163  	}
  7164  	if m.VendorExtension != nil {
  7165  		for _, item := range m.VendorExtension {
  7166  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7167  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7168  		}
  7169  	}
  7170  	return info
  7171  }
  7172  
  7173  // ToRawInfo returns a description of FormDataParameterSubSchema suitable for JSON or YAML export.
  7174  func (m *FormDataParameterSubSchema) ToRawInfo() *yaml.Node {
  7175  	info := compiler.NewMappingNode()
  7176  	if m == nil {
  7177  		return info
  7178  	}
  7179  	if m.Required != false {
  7180  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  7181  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Required))
  7182  	}
  7183  	if m.In != "" {
  7184  		info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  7185  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  7186  	}
  7187  	if m.Description != "" {
  7188  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7189  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7190  	}
  7191  	if m.Name != "" {
  7192  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7193  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7194  	}
  7195  	if m.AllowEmptyValue != false {
  7196  		info.Content = append(info.Content, compiler.NewScalarNodeForString("allowEmptyValue"))
  7197  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.AllowEmptyValue))
  7198  	}
  7199  	if m.Type != "" {
  7200  		info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7201  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7202  	}
  7203  	if m.Format != "" {
  7204  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  7205  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  7206  	}
  7207  	if m.Items != nil {
  7208  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  7209  		info.Content = append(info.Content, m.Items.ToRawInfo())
  7210  	}
  7211  	if m.CollectionFormat != "" {
  7212  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  7213  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  7214  	}
  7215  	if m.Default != nil {
  7216  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  7217  		info.Content = append(info.Content, m.Default.ToRawInfo())
  7218  	}
  7219  	if m.Maximum != 0.0 {
  7220  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  7221  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  7222  	}
  7223  	if m.ExclusiveMaximum != false {
  7224  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  7225  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  7226  	}
  7227  	if m.Minimum != 0.0 {
  7228  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  7229  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  7230  	}
  7231  	if m.ExclusiveMinimum != false {
  7232  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  7233  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  7234  	}
  7235  	if m.MaxLength != 0 {
  7236  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  7237  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  7238  	}
  7239  	if m.MinLength != 0 {
  7240  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  7241  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  7242  	}
  7243  	if m.Pattern != "" {
  7244  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  7245  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  7246  	}
  7247  	if m.MaxItems != 0 {
  7248  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  7249  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  7250  	}
  7251  	if m.MinItems != 0 {
  7252  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  7253  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  7254  	}
  7255  	if m.UniqueItems != false {
  7256  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  7257  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  7258  	}
  7259  	if len(m.Enum) != 0 {
  7260  		items := compiler.NewSequenceNode()
  7261  		for _, item := range m.Enum {
  7262  			items.Content = append(items.Content, item.ToRawInfo())
  7263  		}
  7264  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  7265  		info.Content = append(info.Content, items)
  7266  	}
  7267  	if m.MultipleOf != 0.0 {
  7268  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  7269  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  7270  	}
  7271  	if m.VendorExtension != nil {
  7272  		for _, item := range m.VendorExtension {
  7273  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7274  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7275  		}
  7276  	}
  7277  	return info
  7278  }
  7279  
  7280  // ToRawInfo returns a description of Header suitable for JSON or YAML export.
  7281  func (m *Header) ToRawInfo() *yaml.Node {
  7282  	info := compiler.NewMappingNode()
  7283  	if m == nil {
  7284  		return info
  7285  	}
  7286  	// always include this required field.
  7287  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7288  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7289  	if m.Format != "" {
  7290  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  7291  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  7292  	}
  7293  	if m.Items != nil {
  7294  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  7295  		info.Content = append(info.Content, m.Items.ToRawInfo())
  7296  	}
  7297  	if m.CollectionFormat != "" {
  7298  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  7299  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  7300  	}
  7301  	if m.Default != nil {
  7302  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  7303  		info.Content = append(info.Content, m.Default.ToRawInfo())
  7304  	}
  7305  	if m.Maximum != 0.0 {
  7306  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  7307  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  7308  	}
  7309  	if m.ExclusiveMaximum != false {
  7310  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  7311  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  7312  	}
  7313  	if m.Minimum != 0.0 {
  7314  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  7315  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  7316  	}
  7317  	if m.ExclusiveMinimum != false {
  7318  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  7319  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  7320  	}
  7321  	if m.MaxLength != 0 {
  7322  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  7323  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  7324  	}
  7325  	if m.MinLength != 0 {
  7326  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  7327  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  7328  	}
  7329  	if m.Pattern != "" {
  7330  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  7331  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  7332  	}
  7333  	if m.MaxItems != 0 {
  7334  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  7335  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  7336  	}
  7337  	if m.MinItems != 0 {
  7338  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  7339  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  7340  	}
  7341  	if m.UniqueItems != false {
  7342  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  7343  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  7344  	}
  7345  	if len(m.Enum) != 0 {
  7346  		items := compiler.NewSequenceNode()
  7347  		for _, item := range m.Enum {
  7348  			items.Content = append(items.Content, item.ToRawInfo())
  7349  		}
  7350  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  7351  		info.Content = append(info.Content, items)
  7352  	}
  7353  	if m.MultipleOf != 0.0 {
  7354  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  7355  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  7356  	}
  7357  	if m.Description != "" {
  7358  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7359  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7360  	}
  7361  	if m.VendorExtension != nil {
  7362  		for _, item := range m.VendorExtension {
  7363  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7364  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7365  		}
  7366  	}
  7367  	return info
  7368  }
  7369  
  7370  // ToRawInfo returns a description of HeaderParameterSubSchema suitable for JSON or YAML export.
  7371  func (m *HeaderParameterSubSchema) ToRawInfo() *yaml.Node {
  7372  	info := compiler.NewMappingNode()
  7373  	if m == nil {
  7374  		return info
  7375  	}
  7376  	if m.Required != false {
  7377  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  7378  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Required))
  7379  	}
  7380  	if m.In != "" {
  7381  		info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  7382  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  7383  	}
  7384  	if m.Description != "" {
  7385  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7386  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7387  	}
  7388  	if m.Name != "" {
  7389  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7390  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7391  	}
  7392  	if m.Type != "" {
  7393  		info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7394  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7395  	}
  7396  	if m.Format != "" {
  7397  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  7398  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  7399  	}
  7400  	if m.Items != nil {
  7401  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  7402  		info.Content = append(info.Content, m.Items.ToRawInfo())
  7403  	}
  7404  	if m.CollectionFormat != "" {
  7405  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  7406  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  7407  	}
  7408  	if m.Default != nil {
  7409  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  7410  		info.Content = append(info.Content, m.Default.ToRawInfo())
  7411  	}
  7412  	if m.Maximum != 0.0 {
  7413  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  7414  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  7415  	}
  7416  	if m.ExclusiveMaximum != false {
  7417  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  7418  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  7419  	}
  7420  	if m.Minimum != 0.0 {
  7421  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  7422  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  7423  	}
  7424  	if m.ExclusiveMinimum != false {
  7425  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  7426  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  7427  	}
  7428  	if m.MaxLength != 0 {
  7429  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  7430  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  7431  	}
  7432  	if m.MinLength != 0 {
  7433  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  7434  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  7435  	}
  7436  	if m.Pattern != "" {
  7437  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  7438  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  7439  	}
  7440  	if m.MaxItems != 0 {
  7441  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  7442  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  7443  	}
  7444  	if m.MinItems != 0 {
  7445  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  7446  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  7447  	}
  7448  	if m.UniqueItems != false {
  7449  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  7450  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  7451  	}
  7452  	if len(m.Enum) != 0 {
  7453  		items := compiler.NewSequenceNode()
  7454  		for _, item := range m.Enum {
  7455  			items.Content = append(items.Content, item.ToRawInfo())
  7456  		}
  7457  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  7458  		info.Content = append(info.Content, items)
  7459  	}
  7460  	if m.MultipleOf != 0.0 {
  7461  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  7462  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  7463  	}
  7464  	if m.VendorExtension != nil {
  7465  		for _, item := range m.VendorExtension {
  7466  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7467  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7468  		}
  7469  	}
  7470  	return info
  7471  }
  7472  
  7473  // ToRawInfo returns a description of Headers suitable for JSON or YAML export.
  7474  func (m *Headers) ToRawInfo() *yaml.Node {
  7475  	info := compiler.NewMappingNode()
  7476  	if m == nil {
  7477  		return info
  7478  	}
  7479  	if m.AdditionalProperties != nil {
  7480  		for _, item := range m.AdditionalProperties {
  7481  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7482  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7483  		}
  7484  	}
  7485  	return info
  7486  }
  7487  
  7488  // ToRawInfo returns a description of Info suitable for JSON or YAML export.
  7489  func (m *Info) ToRawInfo() *yaml.Node {
  7490  	info := compiler.NewMappingNode()
  7491  	if m == nil {
  7492  		return info
  7493  	}
  7494  	// always include this required field.
  7495  	info.Content = append(info.Content, compiler.NewScalarNodeForString("title"))
  7496  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Title))
  7497  	// always include this required field.
  7498  	info.Content = append(info.Content, compiler.NewScalarNodeForString("version"))
  7499  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Version))
  7500  	if m.Description != "" {
  7501  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7502  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7503  	}
  7504  	if m.TermsOfService != "" {
  7505  		info.Content = append(info.Content, compiler.NewScalarNodeForString("termsOfService"))
  7506  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.TermsOfService))
  7507  	}
  7508  	if m.Contact != nil {
  7509  		info.Content = append(info.Content, compiler.NewScalarNodeForString("contact"))
  7510  		info.Content = append(info.Content, m.Contact.ToRawInfo())
  7511  	}
  7512  	if m.License != nil {
  7513  		info.Content = append(info.Content, compiler.NewScalarNodeForString("license"))
  7514  		info.Content = append(info.Content, m.License.ToRawInfo())
  7515  	}
  7516  	if m.VendorExtension != nil {
  7517  		for _, item := range m.VendorExtension {
  7518  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7519  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7520  		}
  7521  	}
  7522  	return info
  7523  }
  7524  
  7525  // ToRawInfo returns a description of ItemsItem suitable for JSON or YAML export.
  7526  func (m *ItemsItem) ToRawInfo() *yaml.Node {
  7527  	info := compiler.NewMappingNode()
  7528  	if m == nil {
  7529  		return info
  7530  	}
  7531  	if len(m.Schema) != 0 {
  7532  		items := compiler.NewSequenceNode()
  7533  		for _, item := range m.Schema {
  7534  			items.Content = append(items.Content, item.ToRawInfo())
  7535  		}
  7536  		info.Content = append(info.Content, compiler.NewScalarNodeForString("schema"))
  7537  		info.Content = append(info.Content, items)
  7538  	}
  7539  	return info
  7540  }
  7541  
  7542  // ToRawInfo returns a description of JsonReference suitable for JSON or YAML export.
  7543  func (m *JsonReference) ToRawInfo() *yaml.Node {
  7544  	info := compiler.NewMappingNode()
  7545  	if m == nil {
  7546  		return info
  7547  	}
  7548  	// always include this required field.
  7549  	info.Content = append(info.Content, compiler.NewScalarNodeForString("$ref"))
  7550  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.XRef))
  7551  	if m.Description != "" {
  7552  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7553  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7554  	}
  7555  	return info
  7556  }
  7557  
  7558  // ToRawInfo returns a description of License suitable for JSON or YAML export.
  7559  func (m *License) ToRawInfo() *yaml.Node {
  7560  	info := compiler.NewMappingNode()
  7561  	if m == nil {
  7562  		return info
  7563  	}
  7564  	// always include this required field.
  7565  	info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7566  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7567  	if m.Url != "" {
  7568  		info.Content = append(info.Content, compiler.NewScalarNodeForString("url"))
  7569  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Url))
  7570  	}
  7571  	if m.VendorExtension != nil {
  7572  		for _, item := range m.VendorExtension {
  7573  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7574  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7575  		}
  7576  	}
  7577  	return info
  7578  }
  7579  
  7580  // ToRawInfo returns a description of NamedAny suitable for JSON or YAML export.
  7581  func (m *NamedAny) ToRawInfo() *yaml.Node {
  7582  	info := compiler.NewMappingNode()
  7583  	if m == nil {
  7584  		return info
  7585  	}
  7586  	if m.Name != "" {
  7587  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7588  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7589  	}
  7590  	if m.Value != nil {
  7591  		info.Content = append(info.Content, compiler.NewScalarNodeForString("value"))
  7592  		info.Content = append(info.Content, m.Value.ToRawInfo())
  7593  	}
  7594  	return info
  7595  }
  7596  
  7597  // ToRawInfo returns a description of NamedHeader suitable for JSON or YAML export.
  7598  func (m *NamedHeader) ToRawInfo() *yaml.Node {
  7599  	info := compiler.NewMappingNode()
  7600  	if m == nil {
  7601  		return info
  7602  	}
  7603  	if m.Name != "" {
  7604  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7605  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7606  	}
  7607  	// &{Name:value Type:Header StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7608  	return info
  7609  }
  7610  
  7611  // ToRawInfo returns a description of NamedParameter suitable for JSON or YAML export.
  7612  func (m *NamedParameter) ToRawInfo() *yaml.Node {
  7613  	info := compiler.NewMappingNode()
  7614  	if m == nil {
  7615  		return info
  7616  	}
  7617  	if m.Name != "" {
  7618  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7619  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7620  	}
  7621  	// &{Name:value Type:Parameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7622  	return info
  7623  }
  7624  
  7625  // ToRawInfo returns a description of NamedPathItem suitable for JSON or YAML export.
  7626  func (m *NamedPathItem) ToRawInfo() *yaml.Node {
  7627  	info := compiler.NewMappingNode()
  7628  	if m == nil {
  7629  		return info
  7630  	}
  7631  	if m.Name != "" {
  7632  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7633  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7634  	}
  7635  	// &{Name:value Type:PathItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7636  	return info
  7637  }
  7638  
  7639  // ToRawInfo returns a description of NamedResponse suitable for JSON or YAML export.
  7640  func (m *NamedResponse) ToRawInfo() *yaml.Node {
  7641  	info := compiler.NewMappingNode()
  7642  	if m == nil {
  7643  		return info
  7644  	}
  7645  	if m.Name != "" {
  7646  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7647  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7648  	}
  7649  	// &{Name:value Type:Response StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7650  	return info
  7651  }
  7652  
  7653  // ToRawInfo returns a description of NamedResponseValue suitable for JSON or YAML export.
  7654  func (m *NamedResponseValue) ToRawInfo() *yaml.Node {
  7655  	info := compiler.NewMappingNode()
  7656  	if m == nil {
  7657  		return info
  7658  	}
  7659  	if m.Name != "" {
  7660  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7661  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7662  	}
  7663  	// &{Name:value Type:ResponseValue StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7664  	return info
  7665  }
  7666  
  7667  // ToRawInfo returns a description of NamedSchema suitable for JSON or YAML export.
  7668  func (m *NamedSchema) ToRawInfo() *yaml.Node {
  7669  	info := compiler.NewMappingNode()
  7670  	if m == nil {
  7671  		return info
  7672  	}
  7673  	if m.Name != "" {
  7674  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7675  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7676  	}
  7677  	// &{Name:value Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7678  	return info
  7679  }
  7680  
  7681  // ToRawInfo returns a description of NamedSecurityDefinitionsItem suitable for JSON or YAML export.
  7682  func (m *NamedSecurityDefinitionsItem) ToRawInfo() *yaml.Node {
  7683  	info := compiler.NewMappingNode()
  7684  	if m == nil {
  7685  		return info
  7686  	}
  7687  	if m.Name != "" {
  7688  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7689  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7690  	}
  7691  	// &{Name:value Type:SecurityDefinitionsItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7692  	return info
  7693  }
  7694  
  7695  // ToRawInfo returns a description of NamedString suitable for JSON or YAML export.
  7696  func (m *NamedString) ToRawInfo() *yaml.Node {
  7697  	info := compiler.NewMappingNode()
  7698  	if m == nil {
  7699  		return info
  7700  	}
  7701  	if m.Name != "" {
  7702  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7703  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7704  	}
  7705  	if m.Value != "" {
  7706  		info.Content = append(info.Content, compiler.NewScalarNodeForString("value"))
  7707  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Value))
  7708  	}
  7709  	return info
  7710  }
  7711  
  7712  // ToRawInfo returns a description of NamedStringArray suitable for JSON or YAML export.
  7713  func (m *NamedStringArray) ToRawInfo() *yaml.Node {
  7714  	info := compiler.NewMappingNode()
  7715  	if m == nil {
  7716  		return info
  7717  	}
  7718  	if m.Name != "" {
  7719  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  7720  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  7721  	}
  7722  	// &{Name:value Type:StringArray StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
  7723  	return info
  7724  }
  7725  
  7726  // ToRawInfo returns a description of NonBodyParameter suitable for JSON or YAML export.
  7727  func (m *NonBodyParameter) ToRawInfo() *yaml.Node {
  7728  	// ONE OF WRAPPER
  7729  	// NonBodyParameter
  7730  	// {Name:headerParameterSubSchema Type:HeaderParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7731  	v0 := m.GetHeaderParameterSubSchema()
  7732  	if v0 != nil {
  7733  		return v0.ToRawInfo()
  7734  	}
  7735  	// {Name:formDataParameterSubSchema Type:FormDataParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7736  	v1 := m.GetFormDataParameterSubSchema()
  7737  	if v1 != nil {
  7738  		return v1.ToRawInfo()
  7739  	}
  7740  	// {Name:queryParameterSubSchema Type:QueryParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7741  	v2 := m.GetQueryParameterSubSchema()
  7742  	if v2 != nil {
  7743  		return v2.ToRawInfo()
  7744  	}
  7745  	// {Name:pathParameterSubSchema Type:PathParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7746  	v3 := m.GetPathParameterSubSchema()
  7747  	if v3 != nil {
  7748  		return v3.ToRawInfo()
  7749  	}
  7750  	return compiler.NewNullNode()
  7751  }
  7752  
  7753  // ToRawInfo returns a description of Oauth2AccessCodeSecurity suitable for JSON or YAML export.
  7754  func (m *Oauth2AccessCodeSecurity) ToRawInfo() *yaml.Node {
  7755  	info := compiler.NewMappingNode()
  7756  	if m == nil {
  7757  		return info
  7758  	}
  7759  	// always include this required field.
  7760  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7761  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7762  	// always include this required field.
  7763  	info.Content = append(info.Content, compiler.NewScalarNodeForString("flow"))
  7764  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Flow))
  7765  	if m.Scopes != nil {
  7766  		info.Content = append(info.Content, compiler.NewScalarNodeForString("scopes"))
  7767  		info.Content = append(info.Content, m.Scopes.ToRawInfo())
  7768  	}
  7769  	// always include this required field.
  7770  	info.Content = append(info.Content, compiler.NewScalarNodeForString("authorizationUrl"))
  7771  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.AuthorizationUrl))
  7772  	// always include this required field.
  7773  	info.Content = append(info.Content, compiler.NewScalarNodeForString("tokenUrl"))
  7774  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.TokenUrl))
  7775  	if m.Description != "" {
  7776  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7777  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7778  	}
  7779  	if m.VendorExtension != nil {
  7780  		for _, item := range m.VendorExtension {
  7781  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7782  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7783  		}
  7784  	}
  7785  	return info
  7786  }
  7787  
  7788  // ToRawInfo returns a description of Oauth2ApplicationSecurity suitable for JSON or YAML export.
  7789  func (m *Oauth2ApplicationSecurity) ToRawInfo() *yaml.Node {
  7790  	info := compiler.NewMappingNode()
  7791  	if m == nil {
  7792  		return info
  7793  	}
  7794  	// always include this required field.
  7795  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7796  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7797  	// always include this required field.
  7798  	info.Content = append(info.Content, compiler.NewScalarNodeForString("flow"))
  7799  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Flow))
  7800  	if m.Scopes != nil {
  7801  		info.Content = append(info.Content, compiler.NewScalarNodeForString("scopes"))
  7802  		info.Content = append(info.Content, m.Scopes.ToRawInfo())
  7803  	}
  7804  	// always include this required field.
  7805  	info.Content = append(info.Content, compiler.NewScalarNodeForString("tokenUrl"))
  7806  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.TokenUrl))
  7807  	if m.Description != "" {
  7808  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7809  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7810  	}
  7811  	if m.VendorExtension != nil {
  7812  		for _, item := range m.VendorExtension {
  7813  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7814  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7815  		}
  7816  	}
  7817  	return info
  7818  }
  7819  
  7820  // ToRawInfo returns a description of Oauth2ImplicitSecurity suitable for JSON or YAML export.
  7821  func (m *Oauth2ImplicitSecurity) ToRawInfo() *yaml.Node {
  7822  	info := compiler.NewMappingNode()
  7823  	if m == nil {
  7824  		return info
  7825  	}
  7826  	// always include this required field.
  7827  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7828  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7829  	// always include this required field.
  7830  	info.Content = append(info.Content, compiler.NewScalarNodeForString("flow"))
  7831  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Flow))
  7832  	if m.Scopes != nil {
  7833  		info.Content = append(info.Content, compiler.NewScalarNodeForString("scopes"))
  7834  		info.Content = append(info.Content, m.Scopes.ToRawInfo())
  7835  	}
  7836  	// always include this required field.
  7837  	info.Content = append(info.Content, compiler.NewScalarNodeForString("authorizationUrl"))
  7838  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.AuthorizationUrl))
  7839  	if m.Description != "" {
  7840  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7841  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7842  	}
  7843  	if m.VendorExtension != nil {
  7844  		for _, item := range m.VendorExtension {
  7845  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7846  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7847  		}
  7848  	}
  7849  	return info
  7850  }
  7851  
  7852  // ToRawInfo returns a description of Oauth2PasswordSecurity suitable for JSON or YAML export.
  7853  func (m *Oauth2PasswordSecurity) ToRawInfo() *yaml.Node {
  7854  	info := compiler.NewMappingNode()
  7855  	if m == nil {
  7856  		return info
  7857  	}
  7858  	// always include this required field.
  7859  	info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  7860  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  7861  	// always include this required field.
  7862  	info.Content = append(info.Content, compiler.NewScalarNodeForString("flow"))
  7863  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Flow))
  7864  	if m.Scopes != nil {
  7865  		info.Content = append(info.Content, compiler.NewScalarNodeForString("scopes"))
  7866  		info.Content = append(info.Content, m.Scopes.ToRawInfo())
  7867  	}
  7868  	// always include this required field.
  7869  	info.Content = append(info.Content, compiler.NewScalarNodeForString("tokenUrl"))
  7870  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.TokenUrl))
  7871  	if m.Description != "" {
  7872  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7873  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7874  	}
  7875  	if m.VendorExtension != nil {
  7876  		for _, item := range m.VendorExtension {
  7877  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7878  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7879  		}
  7880  	}
  7881  	return info
  7882  }
  7883  
  7884  // ToRawInfo returns a description of Oauth2Scopes suitable for JSON or YAML export.
  7885  func (m *Oauth2Scopes) ToRawInfo() *yaml.Node {
  7886  	info := compiler.NewMappingNode()
  7887  	if m == nil {
  7888  		return info
  7889  	}
  7890  	// &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:}
  7891  	return info
  7892  }
  7893  
  7894  // ToRawInfo returns a description of Operation suitable for JSON or YAML export.
  7895  func (m *Operation) ToRawInfo() *yaml.Node {
  7896  	info := compiler.NewMappingNode()
  7897  	if m == nil {
  7898  		return info
  7899  	}
  7900  	if len(m.Tags) != 0 {
  7901  		info.Content = append(info.Content, compiler.NewScalarNodeForString("tags"))
  7902  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Tags))
  7903  	}
  7904  	if m.Summary != "" {
  7905  		info.Content = append(info.Content, compiler.NewScalarNodeForString("summary"))
  7906  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Summary))
  7907  	}
  7908  	if m.Description != "" {
  7909  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  7910  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  7911  	}
  7912  	if m.ExternalDocs != nil {
  7913  		info.Content = append(info.Content, compiler.NewScalarNodeForString("externalDocs"))
  7914  		info.Content = append(info.Content, m.ExternalDocs.ToRawInfo())
  7915  	}
  7916  	if m.OperationId != "" {
  7917  		info.Content = append(info.Content, compiler.NewScalarNodeForString("operationId"))
  7918  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.OperationId))
  7919  	}
  7920  	if len(m.Produces) != 0 {
  7921  		info.Content = append(info.Content, compiler.NewScalarNodeForString("produces"))
  7922  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Produces))
  7923  	}
  7924  	if len(m.Consumes) != 0 {
  7925  		info.Content = append(info.Content, compiler.NewScalarNodeForString("consumes"))
  7926  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Consumes))
  7927  	}
  7928  	if len(m.Parameters) != 0 {
  7929  		items := compiler.NewSequenceNode()
  7930  		for _, item := range m.Parameters {
  7931  			items.Content = append(items.Content, item.ToRawInfo())
  7932  		}
  7933  		info.Content = append(info.Content, compiler.NewScalarNodeForString("parameters"))
  7934  		info.Content = append(info.Content, items)
  7935  	}
  7936  	// always include this required field.
  7937  	info.Content = append(info.Content, compiler.NewScalarNodeForString("responses"))
  7938  	info.Content = append(info.Content, m.Responses.ToRawInfo())
  7939  	if len(m.Schemes) != 0 {
  7940  		info.Content = append(info.Content, compiler.NewScalarNodeForString("schemes"))
  7941  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Schemes))
  7942  	}
  7943  	if m.Deprecated != false {
  7944  		info.Content = append(info.Content, compiler.NewScalarNodeForString("deprecated"))
  7945  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Deprecated))
  7946  	}
  7947  	if len(m.Security) != 0 {
  7948  		items := compiler.NewSequenceNode()
  7949  		for _, item := range m.Security {
  7950  			items.Content = append(items.Content, item.ToRawInfo())
  7951  		}
  7952  		info.Content = append(info.Content, compiler.NewScalarNodeForString("security"))
  7953  		info.Content = append(info.Content, items)
  7954  	}
  7955  	if m.VendorExtension != nil {
  7956  		for _, item := range m.VendorExtension {
  7957  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7958  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7959  		}
  7960  	}
  7961  	return info
  7962  }
  7963  
  7964  // ToRawInfo returns a description of Parameter suitable for JSON or YAML export.
  7965  func (m *Parameter) ToRawInfo() *yaml.Node {
  7966  	// ONE OF WRAPPER
  7967  	// Parameter
  7968  	// {Name:bodyParameter Type:BodyParameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7969  	v0 := m.GetBodyParameter()
  7970  	if v0 != nil {
  7971  		return v0.ToRawInfo()
  7972  	}
  7973  	// {Name:nonBodyParameter Type:NonBodyParameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  7974  	v1 := m.GetNonBodyParameter()
  7975  	if v1 != nil {
  7976  		return v1.ToRawInfo()
  7977  	}
  7978  	return compiler.NewNullNode()
  7979  }
  7980  
  7981  // ToRawInfo returns a description of ParameterDefinitions suitable for JSON or YAML export.
  7982  func (m *ParameterDefinitions) ToRawInfo() *yaml.Node {
  7983  	info := compiler.NewMappingNode()
  7984  	if m == nil {
  7985  		return info
  7986  	}
  7987  	if m.AdditionalProperties != nil {
  7988  		for _, item := range m.AdditionalProperties {
  7989  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  7990  			info.Content = append(info.Content, item.Value.ToRawInfo())
  7991  		}
  7992  	}
  7993  	return info
  7994  }
  7995  
  7996  // ToRawInfo returns a description of ParametersItem suitable for JSON or YAML export.
  7997  func (m *ParametersItem) ToRawInfo() *yaml.Node {
  7998  	// ONE OF WRAPPER
  7999  	// ParametersItem
  8000  	// {Name:parameter Type:Parameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8001  	v0 := m.GetParameter()
  8002  	if v0 != nil {
  8003  		return v0.ToRawInfo()
  8004  	}
  8005  	// {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8006  	v1 := m.GetJsonReference()
  8007  	if v1 != nil {
  8008  		return v1.ToRawInfo()
  8009  	}
  8010  	return compiler.NewNullNode()
  8011  }
  8012  
  8013  // ToRawInfo returns a description of PathItem suitable for JSON or YAML export.
  8014  func (m *PathItem) ToRawInfo() *yaml.Node {
  8015  	info := compiler.NewMappingNode()
  8016  	if m == nil {
  8017  		return info
  8018  	}
  8019  	if m.XRef != "" {
  8020  		info.Content = append(info.Content, compiler.NewScalarNodeForString("$ref"))
  8021  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.XRef))
  8022  	}
  8023  	if m.Get != nil {
  8024  		info.Content = append(info.Content, compiler.NewScalarNodeForString("get"))
  8025  		info.Content = append(info.Content, m.Get.ToRawInfo())
  8026  	}
  8027  	if m.Put != nil {
  8028  		info.Content = append(info.Content, compiler.NewScalarNodeForString("put"))
  8029  		info.Content = append(info.Content, m.Put.ToRawInfo())
  8030  	}
  8031  	if m.Post != nil {
  8032  		info.Content = append(info.Content, compiler.NewScalarNodeForString("post"))
  8033  		info.Content = append(info.Content, m.Post.ToRawInfo())
  8034  	}
  8035  	if m.Delete != nil {
  8036  		info.Content = append(info.Content, compiler.NewScalarNodeForString("delete"))
  8037  		info.Content = append(info.Content, m.Delete.ToRawInfo())
  8038  	}
  8039  	if m.Options != nil {
  8040  		info.Content = append(info.Content, compiler.NewScalarNodeForString("options"))
  8041  		info.Content = append(info.Content, m.Options.ToRawInfo())
  8042  	}
  8043  	if m.Head != nil {
  8044  		info.Content = append(info.Content, compiler.NewScalarNodeForString("head"))
  8045  		info.Content = append(info.Content, m.Head.ToRawInfo())
  8046  	}
  8047  	if m.Patch != nil {
  8048  		info.Content = append(info.Content, compiler.NewScalarNodeForString("patch"))
  8049  		info.Content = append(info.Content, m.Patch.ToRawInfo())
  8050  	}
  8051  	if len(m.Parameters) != 0 {
  8052  		items := compiler.NewSequenceNode()
  8053  		for _, item := range m.Parameters {
  8054  			items.Content = append(items.Content, item.ToRawInfo())
  8055  		}
  8056  		info.Content = append(info.Content, compiler.NewScalarNodeForString("parameters"))
  8057  		info.Content = append(info.Content, items)
  8058  	}
  8059  	if m.VendorExtension != nil {
  8060  		for _, item := range m.VendorExtension {
  8061  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8062  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8063  		}
  8064  	}
  8065  	return info
  8066  }
  8067  
  8068  // ToRawInfo returns a description of PathParameterSubSchema suitable for JSON or YAML export.
  8069  func (m *PathParameterSubSchema) ToRawInfo() *yaml.Node {
  8070  	info := compiler.NewMappingNode()
  8071  	if m == nil {
  8072  		return info
  8073  	}
  8074  	// always include this required field.
  8075  	info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  8076  	info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Required))
  8077  	if m.In != "" {
  8078  		info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  8079  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  8080  	}
  8081  	if m.Description != "" {
  8082  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  8083  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  8084  	}
  8085  	if m.Name != "" {
  8086  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  8087  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  8088  	}
  8089  	if m.Type != "" {
  8090  		info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  8091  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  8092  	}
  8093  	if m.Format != "" {
  8094  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  8095  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  8096  	}
  8097  	if m.Items != nil {
  8098  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  8099  		info.Content = append(info.Content, m.Items.ToRawInfo())
  8100  	}
  8101  	if m.CollectionFormat != "" {
  8102  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  8103  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  8104  	}
  8105  	if m.Default != nil {
  8106  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  8107  		info.Content = append(info.Content, m.Default.ToRawInfo())
  8108  	}
  8109  	if m.Maximum != 0.0 {
  8110  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  8111  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  8112  	}
  8113  	if m.ExclusiveMaximum != false {
  8114  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  8115  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  8116  	}
  8117  	if m.Minimum != 0.0 {
  8118  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  8119  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  8120  	}
  8121  	if m.ExclusiveMinimum != false {
  8122  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  8123  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  8124  	}
  8125  	if m.MaxLength != 0 {
  8126  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  8127  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  8128  	}
  8129  	if m.MinLength != 0 {
  8130  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  8131  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  8132  	}
  8133  	if m.Pattern != "" {
  8134  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  8135  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  8136  	}
  8137  	if m.MaxItems != 0 {
  8138  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  8139  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  8140  	}
  8141  	if m.MinItems != 0 {
  8142  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  8143  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  8144  	}
  8145  	if m.UniqueItems != false {
  8146  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  8147  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  8148  	}
  8149  	if len(m.Enum) != 0 {
  8150  		items := compiler.NewSequenceNode()
  8151  		for _, item := range m.Enum {
  8152  			items.Content = append(items.Content, item.ToRawInfo())
  8153  		}
  8154  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  8155  		info.Content = append(info.Content, items)
  8156  	}
  8157  	if m.MultipleOf != 0.0 {
  8158  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  8159  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  8160  	}
  8161  	if m.VendorExtension != nil {
  8162  		for _, item := range m.VendorExtension {
  8163  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8164  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8165  		}
  8166  	}
  8167  	return info
  8168  }
  8169  
  8170  // ToRawInfo returns a description of Paths suitable for JSON or YAML export.
  8171  func (m *Paths) ToRawInfo() *yaml.Node {
  8172  	info := compiler.NewMappingNode()
  8173  	if m == nil {
  8174  		return info
  8175  	}
  8176  	if m.VendorExtension != nil {
  8177  		for _, item := range m.VendorExtension {
  8178  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8179  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8180  		}
  8181  	}
  8182  	if m.Path != nil {
  8183  		for _, item := range m.Path {
  8184  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8185  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8186  		}
  8187  	}
  8188  	return info
  8189  }
  8190  
  8191  // ToRawInfo returns a description of PrimitivesItems suitable for JSON or YAML export.
  8192  func (m *PrimitivesItems) ToRawInfo() *yaml.Node {
  8193  	info := compiler.NewMappingNode()
  8194  	if m == nil {
  8195  		return info
  8196  	}
  8197  	if m.Type != "" {
  8198  		info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  8199  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  8200  	}
  8201  	if m.Format != "" {
  8202  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  8203  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  8204  	}
  8205  	if m.Items != nil {
  8206  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  8207  		info.Content = append(info.Content, m.Items.ToRawInfo())
  8208  	}
  8209  	if m.CollectionFormat != "" {
  8210  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  8211  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  8212  	}
  8213  	if m.Default != nil {
  8214  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  8215  		info.Content = append(info.Content, m.Default.ToRawInfo())
  8216  	}
  8217  	if m.Maximum != 0.0 {
  8218  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  8219  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  8220  	}
  8221  	if m.ExclusiveMaximum != false {
  8222  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  8223  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  8224  	}
  8225  	if m.Minimum != 0.0 {
  8226  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  8227  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  8228  	}
  8229  	if m.ExclusiveMinimum != false {
  8230  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  8231  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  8232  	}
  8233  	if m.MaxLength != 0 {
  8234  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  8235  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  8236  	}
  8237  	if m.MinLength != 0 {
  8238  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  8239  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  8240  	}
  8241  	if m.Pattern != "" {
  8242  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  8243  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  8244  	}
  8245  	if m.MaxItems != 0 {
  8246  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  8247  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  8248  	}
  8249  	if m.MinItems != 0 {
  8250  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  8251  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  8252  	}
  8253  	if m.UniqueItems != false {
  8254  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  8255  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  8256  	}
  8257  	if len(m.Enum) != 0 {
  8258  		items := compiler.NewSequenceNode()
  8259  		for _, item := range m.Enum {
  8260  			items.Content = append(items.Content, item.ToRawInfo())
  8261  		}
  8262  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  8263  		info.Content = append(info.Content, items)
  8264  	}
  8265  	if m.MultipleOf != 0.0 {
  8266  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  8267  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  8268  	}
  8269  	if m.VendorExtension != nil {
  8270  		for _, item := range m.VendorExtension {
  8271  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8272  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8273  		}
  8274  	}
  8275  	return info
  8276  }
  8277  
  8278  // ToRawInfo returns a description of Properties suitable for JSON or YAML export.
  8279  func (m *Properties) ToRawInfo() *yaml.Node {
  8280  	info := compiler.NewMappingNode()
  8281  	if m == nil {
  8282  		return info
  8283  	}
  8284  	if m.AdditionalProperties != nil {
  8285  		for _, item := range m.AdditionalProperties {
  8286  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8287  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8288  		}
  8289  	}
  8290  	return info
  8291  }
  8292  
  8293  // ToRawInfo returns a description of QueryParameterSubSchema suitable for JSON or YAML export.
  8294  func (m *QueryParameterSubSchema) ToRawInfo() *yaml.Node {
  8295  	info := compiler.NewMappingNode()
  8296  	if m == nil {
  8297  		return info
  8298  	}
  8299  	if m.Required != false {
  8300  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  8301  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Required))
  8302  	}
  8303  	if m.In != "" {
  8304  		info.Content = append(info.Content, compiler.NewScalarNodeForString("in"))
  8305  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.In))
  8306  	}
  8307  	if m.Description != "" {
  8308  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  8309  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  8310  	}
  8311  	if m.Name != "" {
  8312  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  8313  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  8314  	}
  8315  	if m.AllowEmptyValue != false {
  8316  		info.Content = append(info.Content, compiler.NewScalarNodeForString("allowEmptyValue"))
  8317  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.AllowEmptyValue))
  8318  	}
  8319  	if m.Type != "" {
  8320  		info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  8321  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type))
  8322  	}
  8323  	if m.Format != "" {
  8324  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  8325  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  8326  	}
  8327  	if m.Items != nil {
  8328  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  8329  		info.Content = append(info.Content, m.Items.ToRawInfo())
  8330  	}
  8331  	if m.CollectionFormat != "" {
  8332  		info.Content = append(info.Content, compiler.NewScalarNodeForString("collectionFormat"))
  8333  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.CollectionFormat))
  8334  	}
  8335  	if m.Default != nil {
  8336  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  8337  		info.Content = append(info.Content, m.Default.ToRawInfo())
  8338  	}
  8339  	if m.Maximum != 0.0 {
  8340  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  8341  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  8342  	}
  8343  	if m.ExclusiveMaximum != false {
  8344  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  8345  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  8346  	}
  8347  	if m.Minimum != 0.0 {
  8348  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  8349  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  8350  	}
  8351  	if m.ExclusiveMinimum != false {
  8352  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  8353  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  8354  	}
  8355  	if m.MaxLength != 0 {
  8356  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  8357  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  8358  	}
  8359  	if m.MinLength != 0 {
  8360  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  8361  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  8362  	}
  8363  	if m.Pattern != "" {
  8364  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  8365  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  8366  	}
  8367  	if m.MaxItems != 0 {
  8368  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  8369  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  8370  	}
  8371  	if m.MinItems != 0 {
  8372  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  8373  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  8374  	}
  8375  	if m.UniqueItems != false {
  8376  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  8377  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  8378  	}
  8379  	if len(m.Enum) != 0 {
  8380  		items := compiler.NewSequenceNode()
  8381  		for _, item := range m.Enum {
  8382  			items.Content = append(items.Content, item.ToRawInfo())
  8383  		}
  8384  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  8385  		info.Content = append(info.Content, items)
  8386  	}
  8387  	if m.MultipleOf != 0.0 {
  8388  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  8389  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  8390  	}
  8391  	if m.VendorExtension != nil {
  8392  		for _, item := range m.VendorExtension {
  8393  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8394  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8395  		}
  8396  	}
  8397  	return info
  8398  }
  8399  
  8400  // ToRawInfo returns a description of Response suitable for JSON or YAML export.
  8401  func (m *Response) ToRawInfo() *yaml.Node {
  8402  	info := compiler.NewMappingNode()
  8403  	if m == nil {
  8404  		return info
  8405  	}
  8406  	// always include this required field.
  8407  	info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  8408  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  8409  	if m.Schema != nil {
  8410  		info.Content = append(info.Content, compiler.NewScalarNodeForString("schema"))
  8411  		info.Content = append(info.Content, m.Schema.ToRawInfo())
  8412  	}
  8413  	if m.Headers != nil {
  8414  		info.Content = append(info.Content, compiler.NewScalarNodeForString("headers"))
  8415  		info.Content = append(info.Content, m.Headers.ToRawInfo())
  8416  	}
  8417  	if m.Examples != nil {
  8418  		info.Content = append(info.Content, compiler.NewScalarNodeForString("examples"))
  8419  		info.Content = append(info.Content, m.Examples.ToRawInfo())
  8420  	}
  8421  	if m.VendorExtension != nil {
  8422  		for _, item := range m.VendorExtension {
  8423  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8424  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8425  		}
  8426  	}
  8427  	return info
  8428  }
  8429  
  8430  // ToRawInfo returns a description of ResponseDefinitions suitable for JSON or YAML export.
  8431  func (m *ResponseDefinitions) ToRawInfo() *yaml.Node {
  8432  	info := compiler.NewMappingNode()
  8433  	if m == nil {
  8434  		return info
  8435  	}
  8436  	if m.AdditionalProperties != nil {
  8437  		for _, item := range m.AdditionalProperties {
  8438  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8439  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8440  		}
  8441  	}
  8442  	return info
  8443  }
  8444  
  8445  // ToRawInfo returns a description of ResponseValue suitable for JSON or YAML export.
  8446  func (m *ResponseValue) ToRawInfo() *yaml.Node {
  8447  	// ONE OF WRAPPER
  8448  	// ResponseValue
  8449  	// {Name:response Type:Response StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8450  	v0 := m.GetResponse()
  8451  	if v0 != nil {
  8452  		return v0.ToRawInfo()
  8453  	}
  8454  	// {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8455  	v1 := m.GetJsonReference()
  8456  	if v1 != nil {
  8457  		return v1.ToRawInfo()
  8458  	}
  8459  	return compiler.NewNullNode()
  8460  }
  8461  
  8462  // ToRawInfo returns a description of Responses suitable for JSON or YAML export.
  8463  func (m *Responses) ToRawInfo() *yaml.Node {
  8464  	info := compiler.NewMappingNode()
  8465  	if m == nil {
  8466  		return info
  8467  	}
  8468  	if m.ResponseCode != nil {
  8469  		for _, item := range m.ResponseCode {
  8470  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8471  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8472  		}
  8473  	}
  8474  	if m.VendorExtension != nil {
  8475  		for _, item := range m.VendorExtension {
  8476  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8477  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8478  		}
  8479  	}
  8480  	return info
  8481  }
  8482  
  8483  // ToRawInfo returns a description of Schema suitable for JSON or YAML export.
  8484  func (m *Schema) ToRawInfo() *yaml.Node {
  8485  	info := compiler.NewMappingNode()
  8486  	if m == nil {
  8487  		return info
  8488  	}
  8489  	if m.XRef != "" {
  8490  		info.Content = append(info.Content, compiler.NewScalarNodeForString("$ref"))
  8491  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.XRef))
  8492  	}
  8493  	if m.Format != "" {
  8494  		info.Content = append(info.Content, compiler.NewScalarNodeForString("format"))
  8495  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Format))
  8496  	}
  8497  	if m.Title != "" {
  8498  		info.Content = append(info.Content, compiler.NewScalarNodeForString("title"))
  8499  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Title))
  8500  	}
  8501  	if m.Description != "" {
  8502  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  8503  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  8504  	}
  8505  	if m.Default != nil {
  8506  		info.Content = append(info.Content, compiler.NewScalarNodeForString("default"))
  8507  		info.Content = append(info.Content, m.Default.ToRawInfo())
  8508  	}
  8509  	if m.MultipleOf != 0.0 {
  8510  		info.Content = append(info.Content, compiler.NewScalarNodeForString("multipleOf"))
  8511  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.MultipleOf))
  8512  	}
  8513  	if m.Maximum != 0.0 {
  8514  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maximum"))
  8515  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Maximum))
  8516  	}
  8517  	if m.ExclusiveMaximum != false {
  8518  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMaximum"))
  8519  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMaximum))
  8520  	}
  8521  	if m.Minimum != 0.0 {
  8522  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minimum"))
  8523  		info.Content = append(info.Content, compiler.NewScalarNodeForFloat(m.Minimum))
  8524  	}
  8525  	if m.ExclusiveMinimum != false {
  8526  		info.Content = append(info.Content, compiler.NewScalarNodeForString("exclusiveMinimum"))
  8527  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ExclusiveMinimum))
  8528  	}
  8529  	if m.MaxLength != 0 {
  8530  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxLength"))
  8531  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxLength))
  8532  	}
  8533  	if m.MinLength != 0 {
  8534  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minLength"))
  8535  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinLength))
  8536  	}
  8537  	if m.Pattern != "" {
  8538  		info.Content = append(info.Content, compiler.NewScalarNodeForString("pattern"))
  8539  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Pattern))
  8540  	}
  8541  	if m.MaxItems != 0 {
  8542  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxItems"))
  8543  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxItems))
  8544  	}
  8545  	if m.MinItems != 0 {
  8546  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minItems"))
  8547  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinItems))
  8548  	}
  8549  	if m.UniqueItems != false {
  8550  		info.Content = append(info.Content, compiler.NewScalarNodeForString("uniqueItems"))
  8551  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.UniqueItems))
  8552  	}
  8553  	if m.MaxProperties != 0 {
  8554  		info.Content = append(info.Content, compiler.NewScalarNodeForString("maxProperties"))
  8555  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MaxProperties))
  8556  	}
  8557  	if m.MinProperties != 0 {
  8558  		info.Content = append(info.Content, compiler.NewScalarNodeForString("minProperties"))
  8559  		info.Content = append(info.Content, compiler.NewScalarNodeForInt(m.MinProperties))
  8560  	}
  8561  	if len(m.Required) != 0 {
  8562  		info.Content = append(info.Content, compiler.NewScalarNodeForString("required"))
  8563  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Required))
  8564  	}
  8565  	if len(m.Enum) != 0 {
  8566  		items := compiler.NewSequenceNode()
  8567  		for _, item := range m.Enum {
  8568  			items.Content = append(items.Content, item.ToRawInfo())
  8569  		}
  8570  		info.Content = append(info.Content, compiler.NewScalarNodeForString("enum"))
  8571  		info.Content = append(info.Content, items)
  8572  	}
  8573  	if m.AdditionalProperties != nil {
  8574  		info.Content = append(info.Content, compiler.NewScalarNodeForString("additionalProperties"))
  8575  		info.Content = append(info.Content, m.AdditionalProperties.ToRawInfo())
  8576  	}
  8577  	if m.Type != nil {
  8578  		if len(m.Type.Value) == 1 {
  8579  			info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  8580  			info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Type.Value[0]))
  8581  		} else {
  8582  			info.Content = append(info.Content, compiler.NewScalarNodeForString("type"))
  8583  			info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Type.Value))
  8584  		}
  8585  	}
  8586  	if m.Items != nil {
  8587  		items := compiler.NewSequenceNode()
  8588  		for _, item := range m.Items.Schema {
  8589  			items.Content = append(items.Content, item.ToRawInfo())
  8590  		}
  8591  		if len(items.Content) == 1 {
  8592  			items = items.Content[0]
  8593  		}
  8594  		info.Content = append(info.Content, compiler.NewScalarNodeForString("items"))
  8595  		info.Content = append(info.Content, items)
  8596  	}
  8597  	if len(m.AllOf) != 0 {
  8598  		items := compiler.NewSequenceNode()
  8599  		for _, item := range m.AllOf {
  8600  			items.Content = append(items.Content, item.ToRawInfo())
  8601  		}
  8602  		info.Content = append(info.Content, compiler.NewScalarNodeForString("allOf"))
  8603  		info.Content = append(info.Content, items)
  8604  	}
  8605  	if m.Properties != nil {
  8606  		info.Content = append(info.Content, compiler.NewScalarNodeForString("properties"))
  8607  		info.Content = append(info.Content, m.Properties.ToRawInfo())
  8608  	}
  8609  	if m.Discriminator != "" {
  8610  		info.Content = append(info.Content, compiler.NewScalarNodeForString("discriminator"))
  8611  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Discriminator))
  8612  	}
  8613  	if m.ReadOnly != false {
  8614  		info.Content = append(info.Content, compiler.NewScalarNodeForString("readOnly"))
  8615  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.ReadOnly))
  8616  	}
  8617  	if m.Xml != nil {
  8618  		info.Content = append(info.Content, compiler.NewScalarNodeForString("xml"))
  8619  		info.Content = append(info.Content, m.Xml.ToRawInfo())
  8620  	}
  8621  	if m.ExternalDocs != nil {
  8622  		info.Content = append(info.Content, compiler.NewScalarNodeForString("externalDocs"))
  8623  		info.Content = append(info.Content, m.ExternalDocs.ToRawInfo())
  8624  	}
  8625  	if m.Example != nil {
  8626  		info.Content = append(info.Content, compiler.NewScalarNodeForString("example"))
  8627  		info.Content = append(info.Content, m.Example.ToRawInfo())
  8628  	}
  8629  	if m.VendorExtension != nil {
  8630  		for _, item := range m.VendorExtension {
  8631  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8632  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8633  		}
  8634  	}
  8635  	return info
  8636  }
  8637  
  8638  // ToRawInfo returns a description of SchemaItem suitable for JSON or YAML export.
  8639  func (m *SchemaItem) ToRawInfo() *yaml.Node {
  8640  	// ONE OF WRAPPER
  8641  	// SchemaItem
  8642  	// {Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8643  	v0 := m.GetSchema()
  8644  	if v0 != nil {
  8645  		return v0.ToRawInfo()
  8646  	}
  8647  	// {Name:fileSchema Type:FileSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8648  	v1 := m.GetFileSchema()
  8649  	if v1 != nil {
  8650  		return v1.ToRawInfo()
  8651  	}
  8652  	return compiler.NewNullNode()
  8653  }
  8654  
  8655  // ToRawInfo returns a description of SecurityDefinitions suitable for JSON or YAML export.
  8656  func (m *SecurityDefinitions) ToRawInfo() *yaml.Node {
  8657  	info := compiler.NewMappingNode()
  8658  	if m == nil {
  8659  		return info
  8660  	}
  8661  	if m.AdditionalProperties != nil {
  8662  		for _, item := range m.AdditionalProperties {
  8663  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8664  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8665  		}
  8666  	}
  8667  	return info
  8668  }
  8669  
  8670  // ToRawInfo returns a description of SecurityDefinitionsItem suitable for JSON or YAML export.
  8671  func (m *SecurityDefinitionsItem) ToRawInfo() *yaml.Node {
  8672  	// ONE OF WRAPPER
  8673  	// SecurityDefinitionsItem
  8674  	// {Name:basicAuthenticationSecurity Type:BasicAuthenticationSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8675  	v0 := m.GetBasicAuthenticationSecurity()
  8676  	if v0 != nil {
  8677  		return v0.ToRawInfo()
  8678  	}
  8679  	// {Name:apiKeySecurity Type:ApiKeySecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8680  	v1 := m.GetApiKeySecurity()
  8681  	if v1 != nil {
  8682  		return v1.ToRawInfo()
  8683  	}
  8684  	// {Name:oauth2ImplicitSecurity Type:Oauth2ImplicitSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8685  	v2 := m.GetOauth2ImplicitSecurity()
  8686  	if v2 != nil {
  8687  		return v2.ToRawInfo()
  8688  	}
  8689  	// {Name:oauth2PasswordSecurity Type:Oauth2PasswordSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8690  	v3 := m.GetOauth2PasswordSecurity()
  8691  	if v3 != nil {
  8692  		return v3.ToRawInfo()
  8693  	}
  8694  	// {Name:oauth2ApplicationSecurity Type:Oauth2ApplicationSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8695  	v4 := m.GetOauth2ApplicationSecurity()
  8696  	if v4 != nil {
  8697  		return v4.ToRawInfo()
  8698  	}
  8699  	// {Name:oauth2AccessCodeSecurity Type:Oauth2AccessCodeSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
  8700  	v5 := m.GetOauth2AccessCodeSecurity()
  8701  	if v5 != nil {
  8702  		return v5.ToRawInfo()
  8703  	}
  8704  	return compiler.NewNullNode()
  8705  }
  8706  
  8707  // ToRawInfo returns a description of SecurityRequirement suitable for JSON or YAML export.
  8708  func (m *SecurityRequirement) ToRawInfo() *yaml.Node {
  8709  	info := compiler.NewMappingNode()
  8710  	if m == nil {
  8711  		return info
  8712  	}
  8713  	if m.AdditionalProperties != nil {
  8714  		for _, item := range m.AdditionalProperties {
  8715  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8716  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8717  		}
  8718  	}
  8719  	return info
  8720  }
  8721  
  8722  // ToRawInfo returns a description of StringArray suitable for JSON or YAML export.
  8723  func (m *StringArray) ToRawInfo() *yaml.Node {
  8724  	return compiler.NewSequenceNodeForStringArray(m.Value)
  8725  }
  8726  
  8727  // ToRawInfo returns a description of Tag suitable for JSON or YAML export.
  8728  func (m *Tag) ToRawInfo() *yaml.Node {
  8729  	info := compiler.NewMappingNode()
  8730  	if m == nil {
  8731  		return info
  8732  	}
  8733  	// always include this required field.
  8734  	info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  8735  	info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  8736  	if m.Description != "" {
  8737  		info.Content = append(info.Content, compiler.NewScalarNodeForString("description"))
  8738  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Description))
  8739  	}
  8740  	if m.ExternalDocs != nil {
  8741  		info.Content = append(info.Content, compiler.NewScalarNodeForString("externalDocs"))
  8742  		info.Content = append(info.Content, m.ExternalDocs.ToRawInfo())
  8743  	}
  8744  	if m.VendorExtension != nil {
  8745  		for _, item := range m.VendorExtension {
  8746  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8747  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8748  		}
  8749  	}
  8750  	return info
  8751  }
  8752  
  8753  // ToRawInfo returns a description of TypeItem suitable for JSON or YAML export.
  8754  func (m *TypeItem) ToRawInfo() *yaml.Node {
  8755  	info := compiler.NewMappingNode()
  8756  	if m == nil {
  8757  		return info
  8758  	}
  8759  	if len(m.Value) != 0 {
  8760  		info.Content = append(info.Content, compiler.NewScalarNodeForString("value"))
  8761  		info.Content = append(info.Content, compiler.NewSequenceNodeForStringArray(m.Value))
  8762  	}
  8763  	return info
  8764  }
  8765  
  8766  // ToRawInfo returns a description of VendorExtension suitable for JSON or YAML export.
  8767  func (m *VendorExtension) ToRawInfo() *yaml.Node {
  8768  	info := compiler.NewMappingNode()
  8769  	if m == nil {
  8770  		return info
  8771  	}
  8772  	if m.AdditionalProperties != nil {
  8773  		for _, item := range m.AdditionalProperties {
  8774  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8775  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8776  		}
  8777  	}
  8778  	return info
  8779  }
  8780  
  8781  // ToRawInfo returns a description of Xml suitable for JSON or YAML export.
  8782  func (m *Xml) ToRawInfo() *yaml.Node {
  8783  	info := compiler.NewMappingNode()
  8784  	if m == nil {
  8785  		return info
  8786  	}
  8787  	if m.Name != "" {
  8788  		info.Content = append(info.Content, compiler.NewScalarNodeForString("name"))
  8789  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Name))
  8790  	}
  8791  	if m.Namespace != "" {
  8792  		info.Content = append(info.Content, compiler.NewScalarNodeForString("namespace"))
  8793  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Namespace))
  8794  	}
  8795  	if m.Prefix != "" {
  8796  		info.Content = append(info.Content, compiler.NewScalarNodeForString("prefix"))
  8797  		info.Content = append(info.Content, compiler.NewScalarNodeForString(m.Prefix))
  8798  	}
  8799  	if m.Attribute != false {
  8800  		info.Content = append(info.Content, compiler.NewScalarNodeForString("attribute"))
  8801  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Attribute))
  8802  	}
  8803  	if m.Wrapped != false {
  8804  		info.Content = append(info.Content, compiler.NewScalarNodeForString("wrapped"))
  8805  		info.Content = append(info.Content, compiler.NewScalarNodeForBool(m.Wrapped))
  8806  	}
  8807  	if m.VendorExtension != nil {
  8808  		for _, item := range m.VendorExtension {
  8809  			info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
  8810  			info.Content = append(info.Content, item.Value.ToRawInfo())
  8811  		}
  8812  	}
  8813  	return info
  8814  }
  8815  
  8816  var (
  8817  	pattern0 = regexp.MustCompile("^x-")
  8818  	pattern1 = regexp.MustCompile("^/")
  8819  	pattern2 = regexp.MustCompile("^([0-9]{3})$|^(default)$")
  8820  )
  8821  

View as plain text