▽

Source file src/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go

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

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

View as plain text