1 // Copyright 2017 Google Inc. All Rights Reserved.
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
7 // http://www.apache.org/licenses/LICENSE-2.0
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.
15 // THIS FILE IS AUTOMATICALLY GENERATED.
21 "github.com/googleapis/gnostic/compiler"
27 // Version returns the package name (and OpenAPI version).
28 func Version() string {
32 // NewAdditionalPropertiesItem creates an object of type AdditionalPropertiesItem if possible, returning an error if not.
33 func NewAdditionalPropertiesItem(in interface{}, context *compiler.Context) (*AdditionalPropertiesItem, error) {
34 errors := make([]error, 0)
35 x := &AdditionalPropertiesItem{}
39 m, ok := compiler.UnpackMap(in)
41 // errors might be ok here, they mean we just don't have the right subtype
42 t, matchingError := NewSchema(m, compiler.NewContext("schema", context))
43 if matchingError == nil {
44 x.Oneof = &AdditionalPropertiesItem_Schema{Schema: t}
47 errors = append(errors, matchingError)
52 boolValue, ok := in.(bool)
54 x.Oneof = &AdditionalPropertiesItem_Boolean{Boolean: boolValue}
57 // since the oneof matched one of its possibilities, discard any matching errors
58 errors = make([]error, 0)
60 return x, compiler.NewErrorGroupOrNil(errors)
63 // NewAny creates an object of type Any if possible, returning an error if not.
64 func NewAny(in interface{}, context *compiler.Context) (*Any, error) {
65 errors := make([]error, 0)
67 bytes, _ := yaml.Marshal(in)
68 x.Yaml = string(bytes)
69 return x, compiler.NewErrorGroupOrNil(errors)
72 // NewApiKeySecurity creates an object of type ApiKeySecurity if possible, returning an error if not.
73 func NewApiKeySecurity(in interface{}, context *compiler.Context) (*ApiKeySecurity, error) {
74 errors := make([]error, 0)
75 x := &ApiKeySecurity{}
76 m, ok := compiler.UnpackMap(in)
78 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
79 errors = append(errors, compiler.NewError(context, message))
81 requiredKeys := []string{"in", "name", "type"}
82 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
83 if len(missingKeys) > 0 {
84 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
85 errors = append(errors, compiler.NewError(context, message))
87 allowedKeys := []string{"description", "in", "name", "type"}
88 allowedPatterns := []*regexp.Regexp{pattern0}
89 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
90 if len(invalidKeys) > 0 {
91 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
92 errors = append(errors, compiler.NewError(context, message))
95 v1 := compiler.MapValueForKey(m, "type")
97 x.Type, ok = v1.(string)
99 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
100 errors = append(errors, compiler.NewError(context, message))
102 // check for valid enum values
104 if ok && !compiler.StringArrayContainsValue([]string{"apiKey"}, x.Type) {
105 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
106 errors = append(errors, compiler.NewError(context, message))
110 v2 := compiler.MapValueForKey(m, "name")
112 x.Name, ok = v2.(string)
114 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v2, v2)
115 errors = append(errors, compiler.NewError(context, message))
119 v3 := compiler.MapValueForKey(m, "in")
121 x.In, ok = v3.(string)
123 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v3, v3)
124 errors = append(errors, compiler.NewError(context, message))
126 // check for valid enum values
128 if ok && !compiler.StringArrayContainsValue([]string{"header", "query"}, x.In) {
129 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v3, v3)
130 errors = append(errors, compiler.NewError(context, message))
133 // string description = 4;
134 v4 := compiler.MapValueForKey(m, "description")
136 x.Description, ok = v4.(string)
138 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v4, v4)
139 errors = append(errors, compiler.NewError(context, message))
142 // repeated NamedAny vendor_extension = 5;
144 x.VendorExtension = make([]*NamedAny, 0)
145 for _, item := range m {
146 k, ok := compiler.StringValue(item.Key)
149 if strings.HasPrefix(k, "x-") {
153 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
156 errors = append(errors, err)
158 bytes, _ := yaml.Marshal(v)
159 result.Yaml = string(bytes)
160 result.Value = resultFromExt
164 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
166 errors = append(errors, err)
169 x.VendorExtension = append(x.VendorExtension, pair)
174 return x, compiler.NewErrorGroupOrNil(errors)
177 // NewBasicAuthenticationSecurity creates an object of type BasicAuthenticationSecurity if possible, returning an error if not.
178 func NewBasicAuthenticationSecurity(in interface{}, context *compiler.Context) (*BasicAuthenticationSecurity, error) {
179 errors := make([]error, 0)
180 x := &BasicAuthenticationSecurity{}
181 m, ok := compiler.UnpackMap(in)
183 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
184 errors = append(errors, compiler.NewError(context, message))
186 requiredKeys := []string{"type"}
187 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
188 if len(missingKeys) > 0 {
189 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
190 errors = append(errors, compiler.NewError(context, message))
192 allowedKeys := []string{"description", "type"}
193 allowedPatterns := []*regexp.Regexp{pattern0}
194 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
195 if len(invalidKeys) > 0 {
196 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
197 errors = append(errors, compiler.NewError(context, message))
200 v1 := compiler.MapValueForKey(m, "type")
202 x.Type, ok = v1.(string)
204 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
205 errors = append(errors, compiler.NewError(context, message))
207 // check for valid enum values
209 if ok && !compiler.StringArrayContainsValue([]string{"basic"}, x.Type) {
210 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
211 errors = append(errors, compiler.NewError(context, message))
214 // string description = 2;
215 v2 := compiler.MapValueForKey(m, "description")
217 x.Description, ok = v2.(string)
219 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v2, v2)
220 errors = append(errors, compiler.NewError(context, message))
223 // repeated NamedAny vendor_extension = 3;
225 x.VendorExtension = make([]*NamedAny, 0)
226 for _, item := range m {
227 k, ok := compiler.StringValue(item.Key)
230 if strings.HasPrefix(k, "x-") {
234 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
237 errors = append(errors, err)
239 bytes, _ := yaml.Marshal(v)
240 result.Yaml = string(bytes)
241 result.Value = resultFromExt
245 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
247 errors = append(errors, err)
250 x.VendorExtension = append(x.VendorExtension, pair)
255 return x, compiler.NewErrorGroupOrNil(errors)
258 // NewBodyParameter creates an object of type BodyParameter if possible, returning an error if not.
259 func NewBodyParameter(in interface{}, context *compiler.Context) (*BodyParameter, error) {
260 errors := make([]error, 0)
261 x := &BodyParameter{}
262 m, ok := compiler.UnpackMap(in)
264 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
265 errors = append(errors, compiler.NewError(context, message))
267 requiredKeys := []string{"in", "name", "schema"}
268 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
269 if len(missingKeys) > 0 {
270 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
271 errors = append(errors, compiler.NewError(context, message))
273 allowedKeys := []string{"description", "in", "name", "required", "schema"}
274 allowedPatterns := []*regexp.Regexp{pattern0}
275 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
276 if len(invalidKeys) > 0 {
277 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
278 errors = append(errors, compiler.NewError(context, message))
280 // string description = 1;
281 v1 := compiler.MapValueForKey(m, "description")
283 x.Description, ok = v1.(string)
285 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v1, v1)
286 errors = append(errors, compiler.NewError(context, message))
290 v2 := compiler.MapValueForKey(m, "name")
292 x.Name, ok = v2.(string)
294 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v2, v2)
295 errors = append(errors, compiler.NewError(context, message))
299 v3 := compiler.MapValueForKey(m, "in")
301 x.In, ok = v3.(string)
303 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v3, v3)
304 errors = append(errors, compiler.NewError(context, message))
306 // check for valid enum values
308 if ok && !compiler.StringArrayContainsValue([]string{"body"}, x.In) {
309 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v3, v3)
310 errors = append(errors, compiler.NewError(context, message))
313 // bool required = 4;
314 v4 := compiler.MapValueForKey(m, "required")
316 x.Required, ok = v4.(bool)
318 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v4, v4)
319 errors = append(errors, compiler.NewError(context, message))
322 // Schema schema = 5;
323 v5 := compiler.MapValueForKey(m, "schema")
326 x.Schema, err = NewSchema(v5, compiler.NewContext("schema", context))
328 errors = append(errors, err)
331 // repeated NamedAny vendor_extension = 6;
333 x.VendorExtension = make([]*NamedAny, 0)
334 for _, item := range m {
335 k, ok := compiler.StringValue(item.Key)
338 if strings.HasPrefix(k, "x-") {
342 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
345 errors = append(errors, err)
347 bytes, _ := yaml.Marshal(v)
348 result.Yaml = string(bytes)
349 result.Value = resultFromExt
353 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
355 errors = append(errors, err)
358 x.VendorExtension = append(x.VendorExtension, pair)
363 return x, compiler.NewErrorGroupOrNil(errors)
366 // NewContact creates an object of type Contact if possible, returning an error if not.
367 func NewContact(in interface{}, context *compiler.Context) (*Contact, error) {
368 errors := make([]error, 0)
370 m, ok := compiler.UnpackMap(in)
372 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
373 errors = append(errors, compiler.NewError(context, message))
375 allowedKeys := []string{"email", "name", "url"}
376 allowedPatterns := []*regexp.Regexp{pattern0}
377 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
378 if len(invalidKeys) > 0 {
379 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
380 errors = append(errors, compiler.NewError(context, message))
383 v1 := compiler.MapValueForKey(m, "name")
385 x.Name, ok = v1.(string)
387 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
388 errors = append(errors, compiler.NewError(context, message))
392 v2 := compiler.MapValueForKey(m, "url")
394 x.Url, ok = v2.(string)
396 message := fmt.Sprintf("has unexpected value for url: %+v (%T)", v2, v2)
397 errors = append(errors, compiler.NewError(context, message))
401 v3 := compiler.MapValueForKey(m, "email")
403 x.Email, ok = v3.(string)
405 message := fmt.Sprintf("has unexpected value for email: %+v (%T)", v3, v3)
406 errors = append(errors, compiler.NewError(context, message))
409 // repeated NamedAny vendor_extension = 4;
411 x.VendorExtension = make([]*NamedAny, 0)
412 for _, item := range m {
413 k, ok := compiler.StringValue(item.Key)
416 if strings.HasPrefix(k, "x-") {
420 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
423 errors = append(errors, err)
425 bytes, _ := yaml.Marshal(v)
426 result.Yaml = string(bytes)
427 result.Value = resultFromExt
431 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
433 errors = append(errors, err)
436 x.VendorExtension = append(x.VendorExtension, pair)
441 return x, compiler.NewErrorGroupOrNil(errors)
444 // NewDefault creates an object of type Default if possible, returning an error if not.
445 func NewDefault(in interface{}, context *compiler.Context) (*Default, error) {
446 errors := make([]error, 0)
448 m, ok := compiler.UnpackMap(in)
450 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
451 errors = append(errors, compiler.NewError(context, message))
453 // repeated NamedAny additional_properties = 1;
455 x.AdditionalProperties = make([]*NamedAny, 0)
456 for _, item := range m {
457 k, ok := compiler.StringValue(item.Key)
463 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
466 errors = append(errors, err)
468 bytes, _ := yaml.Marshal(v)
469 result.Yaml = string(bytes)
470 result.Value = resultFromExt
474 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
476 errors = append(errors, err)
479 x.AdditionalProperties = append(x.AdditionalProperties, pair)
483 return x, compiler.NewErrorGroupOrNil(errors)
486 // NewDefinitions creates an object of type Definitions if possible, returning an error if not.
487 func NewDefinitions(in interface{}, context *compiler.Context) (*Definitions, error) {
488 errors := make([]error, 0)
490 m, ok := compiler.UnpackMap(in)
492 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
493 errors = append(errors, compiler.NewError(context, message))
495 // repeated NamedSchema additional_properties = 1;
497 x.AdditionalProperties = make([]*NamedSchema, 0)
498 for _, item := range m {
499 k, ok := compiler.StringValue(item.Key)
502 pair := &NamedSchema{}
505 pair.Value, err = NewSchema(v, compiler.NewContext(k, context))
507 errors = append(errors, err)
509 x.AdditionalProperties = append(x.AdditionalProperties, pair)
513 return x, compiler.NewErrorGroupOrNil(errors)
516 // NewDocument creates an object of type Document if possible, returning an error if not.
517 func NewDocument(in interface{}, context *compiler.Context) (*Document, error) {
518 errors := make([]error, 0)
520 m, ok := compiler.UnpackMap(in)
522 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
523 errors = append(errors, compiler.NewError(context, message))
525 requiredKeys := []string{"info", "paths", "swagger"}
526 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
527 if len(missingKeys) > 0 {
528 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
529 errors = append(errors, compiler.NewError(context, message))
531 allowedKeys := []string{"basePath", "consumes", "definitions", "externalDocs", "host", "info", "parameters", "paths", "produces", "responses", "schemes", "security", "securityDefinitions", "swagger", "tags"}
532 allowedPatterns := []*regexp.Regexp{pattern0}
533 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
534 if len(invalidKeys) > 0 {
535 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
536 errors = append(errors, compiler.NewError(context, message))
538 // string swagger = 1;
539 v1 := compiler.MapValueForKey(m, "swagger")
541 x.Swagger, ok = v1.(string)
543 message := fmt.Sprintf("has unexpected value for swagger: %+v (%T)", v1, v1)
544 errors = append(errors, compiler.NewError(context, message))
546 // check for valid enum values
548 if ok && !compiler.StringArrayContainsValue([]string{"2.0"}, x.Swagger) {
549 message := fmt.Sprintf("has unexpected value for swagger: %+v (%T)", v1, v1)
550 errors = append(errors, compiler.NewError(context, message))
554 v2 := compiler.MapValueForKey(m, "info")
557 x.Info, err = NewInfo(v2, compiler.NewContext("info", context))
559 errors = append(errors, err)
563 v3 := compiler.MapValueForKey(m, "host")
565 x.Host, ok = v3.(string)
567 message := fmt.Sprintf("has unexpected value for host: %+v (%T)", v3, v3)
568 errors = append(errors, compiler.NewError(context, message))
571 // string base_path = 4;
572 v4 := compiler.MapValueForKey(m, "basePath")
574 x.BasePath, ok = v4.(string)
576 message := fmt.Sprintf("has unexpected value for basePath: %+v (%T)", v4, v4)
577 errors = append(errors, compiler.NewError(context, message))
580 // repeated string schemes = 5;
581 v5 := compiler.MapValueForKey(m, "schemes")
583 v, ok := v5.([]interface{})
585 x.Schemes = compiler.ConvertInterfaceArrayToStringArray(v)
587 message := fmt.Sprintf("has unexpected value for schemes: %+v (%T)", v5, v5)
588 errors = append(errors, compiler.NewError(context, message))
590 // check for valid enum values
591 // [http https ws wss]
592 if ok && !compiler.StringArrayContainsValues([]string{"http", "https", "ws", "wss"}, x.Schemes) {
593 message := fmt.Sprintf("has unexpected value for schemes: %+v", v5)
594 errors = append(errors, compiler.NewError(context, message))
597 // repeated string consumes = 6;
598 v6 := compiler.MapValueForKey(m, "consumes")
600 v, ok := v6.([]interface{})
602 x.Consumes = compiler.ConvertInterfaceArrayToStringArray(v)
604 message := fmt.Sprintf("has unexpected value for consumes: %+v (%T)", v6, v6)
605 errors = append(errors, compiler.NewError(context, message))
608 // repeated string produces = 7;
609 v7 := compiler.MapValueForKey(m, "produces")
611 v, ok := v7.([]interface{})
613 x.Produces = compiler.ConvertInterfaceArrayToStringArray(v)
615 message := fmt.Sprintf("has unexpected value for produces: %+v (%T)", v7, v7)
616 errors = append(errors, compiler.NewError(context, message))
620 v8 := compiler.MapValueForKey(m, "paths")
623 x.Paths, err = NewPaths(v8, compiler.NewContext("paths", context))
625 errors = append(errors, err)
628 // Definitions definitions = 9;
629 v9 := compiler.MapValueForKey(m, "definitions")
632 x.Definitions, err = NewDefinitions(v9, compiler.NewContext("definitions", context))
634 errors = append(errors, err)
637 // ParameterDefinitions parameters = 10;
638 v10 := compiler.MapValueForKey(m, "parameters")
641 x.Parameters, err = NewParameterDefinitions(v10, compiler.NewContext("parameters", context))
643 errors = append(errors, err)
646 // ResponseDefinitions responses = 11;
647 v11 := compiler.MapValueForKey(m, "responses")
650 x.Responses, err = NewResponseDefinitions(v11, compiler.NewContext("responses", context))
652 errors = append(errors, err)
655 // repeated SecurityRequirement security = 12;
656 v12 := compiler.MapValueForKey(m, "security")
658 // repeated SecurityRequirement
659 x.Security = make([]*SecurityRequirement, 0)
660 a, ok := v12.([]interface{})
662 for _, item := range a {
663 y, err := NewSecurityRequirement(item, compiler.NewContext("security", context))
665 errors = append(errors, err)
667 x.Security = append(x.Security, y)
671 // SecurityDefinitions security_definitions = 13;
672 v13 := compiler.MapValueForKey(m, "securityDefinitions")
675 x.SecurityDefinitions, err = NewSecurityDefinitions(v13, compiler.NewContext("securityDefinitions", context))
677 errors = append(errors, err)
680 // repeated Tag tags = 14;
681 v14 := compiler.MapValueForKey(m, "tags")
684 x.Tags = make([]*Tag, 0)
685 a, ok := v14.([]interface{})
687 for _, item := range a {
688 y, err := NewTag(item, compiler.NewContext("tags", context))
690 errors = append(errors, err)
692 x.Tags = append(x.Tags, y)
696 // ExternalDocs external_docs = 15;
697 v15 := compiler.MapValueForKey(m, "externalDocs")
700 x.ExternalDocs, err = NewExternalDocs(v15, compiler.NewContext("externalDocs", context))
702 errors = append(errors, err)
705 // repeated NamedAny vendor_extension = 16;
707 x.VendorExtension = make([]*NamedAny, 0)
708 for _, item := range m {
709 k, ok := compiler.StringValue(item.Key)
712 if strings.HasPrefix(k, "x-") {
716 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
719 errors = append(errors, err)
721 bytes, _ := yaml.Marshal(v)
722 result.Yaml = string(bytes)
723 result.Value = resultFromExt
727 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
729 errors = append(errors, err)
732 x.VendorExtension = append(x.VendorExtension, pair)
737 return x, compiler.NewErrorGroupOrNil(errors)
740 // NewExamples creates an object of type Examples if possible, returning an error if not.
741 func NewExamples(in interface{}, context *compiler.Context) (*Examples, error) {
742 errors := make([]error, 0)
744 m, ok := compiler.UnpackMap(in)
746 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
747 errors = append(errors, compiler.NewError(context, message))
749 // repeated NamedAny additional_properties = 1;
751 x.AdditionalProperties = make([]*NamedAny, 0)
752 for _, item := range m {
753 k, ok := compiler.StringValue(item.Key)
759 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
762 errors = append(errors, err)
764 bytes, _ := yaml.Marshal(v)
765 result.Yaml = string(bytes)
766 result.Value = resultFromExt
770 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
772 errors = append(errors, err)
775 x.AdditionalProperties = append(x.AdditionalProperties, pair)
779 return x, compiler.NewErrorGroupOrNil(errors)
782 // NewExternalDocs creates an object of type ExternalDocs if possible, returning an error if not.
783 func NewExternalDocs(in interface{}, context *compiler.Context) (*ExternalDocs, error) {
784 errors := make([]error, 0)
786 m, ok := compiler.UnpackMap(in)
788 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
789 errors = append(errors, compiler.NewError(context, message))
791 requiredKeys := []string{"url"}
792 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
793 if len(missingKeys) > 0 {
794 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
795 errors = append(errors, compiler.NewError(context, message))
797 allowedKeys := []string{"description", "url"}
798 allowedPatterns := []*regexp.Regexp{pattern0}
799 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
800 if len(invalidKeys) > 0 {
801 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
802 errors = append(errors, compiler.NewError(context, message))
804 // string description = 1;
805 v1 := compiler.MapValueForKey(m, "description")
807 x.Description, ok = v1.(string)
809 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v1, v1)
810 errors = append(errors, compiler.NewError(context, message))
814 v2 := compiler.MapValueForKey(m, "url")
816 x.Url, ok = v2.(string)
818 message := fmt.Sprintf("has unexpected value for url: %+v (%T)", v2, v2)
819 errors = append(errors, compiler.NewError(context, message))
822 // repeated NamedAny vendor_extension = 3;
824 x.VendorExtension = make([]*NamedAny, 0)
825 for _, item := range m {
826 k, ok := compiler.StringValue(item.Key)
829 if strings.HasPrefix(k, "x-") {
833 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
836 errors = append(errors, err)
838 bytes, _ := yaml.Marshal(v)
839 result.Yaml = string(bytes)
840 result.Value = resultFromExt
844 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
846 errors = append(errors, err)
849 x.VendorExtension = append(x.VendorExtension, pair)
854 return x, compiler.NewErrorGroupOrNil(errors)
857 // NewFileSchema creates an object of type FileSchema if possible, returning an error if not.
858 func NewFileSchema(in interface{}, context *compiler.Context) (*FileSchema, error) {
859 errors := make([]error, 0)
861 m, ok := compiler.UnpackMap(in)
863 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
864 errors = append(errors, compiler.NewError(context, message))
866 requiredKeys := []string{"type"}
867 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
868 if len(missingKeys) > 0 {
869 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
870 errors = append(errors, compiler.NewError(context, message))
872 allowedKeys := []string{"default", "description", "example", "externalDocs", "format", "readOnly", "required", "title", "type"}
873 allowedPatterns := []*regexp.Regexp{pattern0}
874 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
875 if len(invalidKeys) > 0 {
876 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
877 errors = append(errors, compiler.NewError(context, message))
879 // string format = 1;
880 v1 := compiler.MapValueForKey(m, "format")
882 x.Format, ok = v1.(string)
884 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v1, v1)
885 errors = append(errors, compiler.NewError(context, message))
889 v2 := compiler.MapValueForKey(m, "title")
891 x.Title, ok = v2.(string)
893 message := fmt.Sprintf("has unexpected value for title: %+v (%T)", v2, v2)
894 errors = append(errors, compiler.NewError(context, message))
897 // string description = 3;
898 v3 := compiler.MapValueForKey(m, "description")
900 x.Description, ok = v3.(string)
902 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
903 errors = append(errors, compiler.NewError(context, message))
907 v4 := compiler.MapValueForKey(m, "default")
910 x.Default, err = NewAny(v4, compiler.NewContext("default", context))
912 errors = append(errors, err)
915 // repeated string required = 5;
916 v5 := compiler.MapValueForKey(m, "required")
918 v, ok := v5.([]interface{})
920 x.Required = compiler.ConvertInterfaceArrayToStringArray(v)
922 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v5, v5)
923 errors = append(errors, compiler.NewError(context, message))
927 v6 := compiler.MapValueForKey(m, "type")
929 x.Type, ok = v6.(string)
931 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
932 errors = append(errors, compiler.NewError(context, message))
934 // check for valid enum values
936 if ok && !compiler.StringArrayContainsValue([]string{"file"}, x.Type) {
937 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
938 errors = append(errors, compiler.NewError(context, message))
941 // bool read_only = 7;
942 v7 := compiler.MapValueForKey(m, "readOnly")
944 x.ReadOnly, ok = v7.(bool)
946 message := fmt.Sprintf("has unexpected value for readOnly: %+v (%T)", v7, v7)
947 errors = append(errors, compiler.NewError(context, message))
950 // ExternalDocs external_docs = 8;
951 v8 := compiler.MapValueForKey(m, "externalDocs")
954 x.ExternalDocs, err = NewExternalDocs(v8, compiler.NewContext("externalDocs", context))
956 errors = append(errors, err)
960 v9 := compiler.MapValueForKey(m, "example")
963 x.Example, err = NewAny(v9, compiler.NewContext("example", context))
965 errors = append(errors, err)
968 // repeated NamedAny vendor_extension = 10;
970 x.VendorExtension = make([]*NamedAny, 0)
971 for _, item := range m {
972 k, ok := compiler.StringValue(item.Key)
975 if strings.HasPrefix(k, "x-") {
979 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
982 errors = append(errors, err)
984 bytes, _ := yaml.Marshal(v)
985 result.Yaml = string(bytes)
986 result.Value = resultFromExt
990 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
992 errors = append(errors, err)
995 x.VendorExtension = append(x.VendorExtension, pair)
1000 return x, compiler.NewErrorGroupOrNil(errors)
1003 // NewFormDataParameterSubSchema creates an object of type FormDataParameterSubSchema if possible, returning an error if not.
1004 func NewFormDataParameterSubSchema(in interface{}, context *compiler.Context) (*FormDataParameterSubSchema, error) {
1005 errors := make([]error, 0)
1006 x := &FormDataParameterSubSchema{}
1007 m, ok := compiler.UnpackMap(in)
1009 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
1010 errors = append(errors, compiler.NewError(context, message))
1012 allowedKeys := []string{"allowEmptyValue", "collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
1013 allowedPatterns := []*regexp.Regexp{pattern0}
1014 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
1015 if len(invalidKeys) > 0 {
1016 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
1017 errors = append(errors, compiler.NewError(context, message))
1019 // bool required = 1;
1020 v1 := compiler.MapValueForKey(m, "required")
1022 x.Required, ok = v1.(bool)
1024 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v1, v1)
1025 errors = append(errors, compiler.NewError(context, message))
1029 v2 := compiler.MapValueForKey(m, "in")
1031 x.In, ok = v2.(string)
1033 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
1034 errors = append(errors, compiler.NewError(context, message))
1036 // check for valid enum values
1038 if ok && !compiler.StringArrayContainsValue([]string{"formData"}, x.In) {
1039 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
1040 errors = append(errors, compiler.NewError(context, message))
1043 // string description = 3;
1044 v3 := compiler.MapValueForKey(m, "description")
1046 x.Description, ok = v3.(string)
1048 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
1049 errors = append(errors, compiler.NewError(context, message))
1053 v4 := compiler.MapValueForKey(m, "name")
1055 x.Name, ok = v4.(string)
1057 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v4, v4)
1058 errors = append(errors, compiler.NewError(context, message))
1061 // bool allow_empty_value = 5;
1062 v5 := compiler.MapValueForKey(m, "allowEmptyValue")
1064 x.AllowEmptyValue, ok = v5.(bool)
1066 message := fmt.Sprintf("has unexpected value for allowEmptyValue: %+v (%T)", v5, v5)
1067 errors = append(errors, compiler.NewError(context, message))
1071 v6 := compiler.MapValueForKey(m, "type")
1073 x.Type, ok = v6.(string)
1075 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
1076 errors = append(errors, compiler.NewError(context, message))
1078 // check for valid enum values
1079 // [string number boolean integer array file]
1080 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array", "file"}, x.Type) {
1081 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
1082 errors = append(errors, compiler.NewError(context, message))
1085 // string format = 7;
1086 v7 := compiler.MapValueForKey(m, "format")
1088 x.Format, ok = v7.(string)
1090 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v7, v7)
1091 errors = append(errors, compiler.NewError(context, message))
1094 // PrimitivesItems items = 8;
1095 v8 := compiler.MapValueForKey(m, "items")
1098 x.Items, err = NewPrimitivesItems(v8, compiler.NewContext("items", context))
1100 errors = append(errors, err)
1103 // string collection_format = 9;
1104 v9 := compiler.MapValueForKey(m, "collectionFormat")
1106 x.CollectionFormat, ok = v9.(string)
1108 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v9, v9)
1109 errors = append(errors, compiler.NewError(context, message))
1111 // check for valid enum values
1112 // [csv ssv tsv pipes multi]
1113 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes", "multi"}, x.CollectionFormat) {
1114 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v9, v9)
1115 errors = append(errors, compiler.NewError(context, message))
1118 // Any default = 10;
1119 v10 := compiler.MapValueForKey(m, "default")
1122 x.Default, err = NewAny(v10, compiler.NewContext("default", context))
1124 errors = append(errors, err)
1127 // float maximum = 11;
1128 v11 := compiler.MapValueForKey(m, "maximum")
1130 switch v11 := v11.(type) {
1134 x.Maximum = float64(v11)
1136 x.Maximum = float64(v11)
1138 x.Maximum = float64(v11)
1140 x.Maximum = float64(v11)
1142 x.Maximum = float64(v11)
1144 x.Maximum = float64(v11)
1146 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v11, v11)
1147 errors = append(errors, compiler.NewError(context, message))
1150 // bool exclusive_maximum = 12;
1151 v12 := compiler.MapValueForKey(m, "exclusiveMaximum")
1153 x.ExclusiveMaximum, ok = v12.(bool)
1155 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v12, v12)
1156 errors = append(errors, compiler.NewError(context, message))
1159 // float minimum = 13;
1160 v13 := compiler.MapValueForKey(m, "minimum")
1162 switch v13 := v13.(type) {
1166 x.Minimum = float64(v13)
1168 x.Minimum = float64(v13)
1170 x.Minimum = float64(v13)
1172 x.Minimum = float64(v13)
1174 x.Minimum = float64(v13)
1176 x.Minimum = float64(v13)
1178 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v13, v13)
1179 errors = append(errors, compiler.NewError(context, message))
1182 // bool exclusive_minimum = 14;
1183 v14 := compiler.MapValueForKey(m, "exclusiveMinimum")
1185 x.ExclusiveMinimum, ok = v14.(bool)
1187 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v14, v14)
1188 errors = append(errors, compiler.NewError(context, message))
1191 // int64 max_length = 15;
1192 v15 := compiler.MapValueForKey(m, "maxLength")
1196 x.MaxLength = int64(t)
1198 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v15, v15)
1199 errors = append(errors, compiler.NewError(context, message))
1202 // int64 min_length = 16;
1203 v16 := compiler.MapValueForKey(m, "minLength")
1207 x.MinLength = int64(t)
1209 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v16, v16)
1210 errors = append(errors, compiler.NewError(context, message))
1213 // string pattern = 17;
1214 v17 := compiler.MapValueForKey(m, "pattern")
1216 x.Pattern, ok = v17.(string)
1218 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v17, v17)
1219 errors = append(errors, compiler.NewError(context, message))
1222 // int64 max_items = 18;
1223 v18 := compiler.MapValueForKey(m, "maxItems")
1227 x.MaxItems = int64(t)
1229 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v18, v18)
1230 errors = append(errors, compiler.NewError(context, message))
1233 // int64 min_items = 19;
1234 v19 := compiler.MapValueForKey(m, "minItems")
1238 x.MinItems = int64(t)
1240 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v19, v19)
1241 errors = append(errors, compiler.NewError(context, message))
1244 // bool unique_items = 20;
1245 v20 := compiler.MapValueForKey(m, "uniqueItems")
1247 x.UniqueItems, ok = v20.(bool)
1249 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v20, v20)
1250 errors = append(errors, compiler.NewError(context, message))
1253 // repeated Any enum = 21;
1254 v21 := compiler.MapValueForKey(m, "enum")
1257 x.Enum = make([]*Any, 0)
1258 a, ok := v21.([]interface{})
1260 for _, item := range a {
1261 y, err := NewAny(item, compiler.NewContext("enum", context))
1263 errors = append(errors, err)
1265 x.Enum = append(x.Enum, y)
1269 // float multiple_of = 22;
1270 v22 := compiler.MapValueForKey(m, "multipleOf")
1272 switch v22 := v22.(type) {
1276 x.MultipleOf = float64(v22)
1278 x.MultipleOf = float64(v22)
1280 x.MultipleOf = float64(v22)
1282 x.MultipleOf = float64(v22)
1284 x.MultipleOf = float64(v22)
1286 x.MultipleOf = float64(v22)
1288 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v22, v22)
1289 errors = append(errors, compiler.NewError(context, message))
1292 // repeated NamedAny vendor_extension = 23;
1294 x.VendorExtension = make([]*NamedAny, 0)
1295 for _, item := range m {
1296 k, ok := compiler.StringValue(item.Key)
1299 if strings.HasPrefix(k, "x-") {
1303 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
1306 errors = append(errors, err)
1308 bytes, _ := yaml.Marshal(v)
1309 result.Yaml = string(bytes)
1310 result.Value = resultFromExt
1314 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
1316 errors = append(errors, err)
1319 x.VendorExtension = append(x.VendorExtension, pair)
1324 return x, compiler.NewErrorGroupOrNil(errors)
1327 // NewHeader creates an object of type Header if possible, returning an error if not.
1328 func NewHeader(in interface{}, context *compiler.Context) (*Header, error) {
1329 errors := make([]error, 0)
1331 m, ok := compiler.UnpackMap(in)
1333 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
1334 errors = append(errors, compiler.NewError(context, message))
1336 requiredKeys := []string{"type"}
1337 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
1338 if len(missingKeys) > 0 {
1339 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
1340 errors = append(errors, compiler.NewError(context, message))
1342 allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "pattern", "type", "uniqueItems"}
1343 allowedPatterns := []*regexp.Regexp{pattern0}
1344 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
1345 if len(invalidKeys) > 0 {
1346 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
1347 errors = append(errors, compiler.NewError(context, message))
1350 v1 := compiler.MapValueForKey(m, "type")
1352 x.Type, ok = v1.(string)
1354 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
1355 errors = append(errors, compiler.NewError(context, message))
1357 // check for valid enum values
1358 // [string number integer boolean array]
1359 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "integer", "boolean", "array"}, x.Type) {
1360 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
1361 errors = append(errors, compiler.NewError(context, message))
1364 // string format = 2;
1365 v2 := compiler.MapValueForKey(m, "format")
1367 x.Format, ok = v2.(string)
1369 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v2, v2)
1370 errors = append(errors, compiler.NewError(context, message))
1373 // PrimitivesItems items = 3;
1374 v3 := compiler.MapValueForKey(m, "items")
1377 x.Items, err = NewPrimitivesItems(v3, compiler.NewContext("items", context))
1379 errors = append(errors, err)
1382 // string collection_format = 4;
1383 v4 := compiler.MapValueForKey(m, "collectionFormat")
1385 x.CollectionFormat, ok = v4.(string)
1387 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v4, v4)
1388 errors = append(errors, compiler.NewError(context, message))
1390 // check for valid enum values
1391 // [csv ssv tsv pipes]
1392 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
1393 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v4, v4)
1394 errors = append(errors, compiler.NewError(context, message))
1398 v5 := compiler.MapValueForKey(m, "default")
1401 x.Default, err = NewAny(v5, compiler.NewContext("default", context))
1403 errors = append(errors, err)
1406 // float maximum = 6;
1407 v6 := compiler.MapValueForKey(m, "maximum")
1409 switch v6 := v6.(type) {
1413 x.Maximum = float64(v6)
1415 x.Maximum = float64(v6)
1417 x.Maximum = float64(v6)
1419 x.Maximum = float64(v6)
1421 x.Maximum = float64(v6)
1423 x.Maximum = float64(v6)
1425 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v6, v6)
1426 errors = append(errors, compiler.NewError(context, message))
1429 // bool exclusive_maximum = 7;
1430 v7 := compiler.MapValueForKey(m, "exclusiveMaximum")
1432 x.ExclusiveMaximum, ok = v7.(bool)
1434 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v7, v7)
1435 errors = append(errors, compiler.NewError(context, message))
1438 // float minimum = 8;
1439 v8 := compiler.MapValueForKey(m, "minimum")
1441 switch v8 := v8.(type) {
1445 x.Minimum = float64(v8)
1447 x.Minimum = float64(v8)
1449 x.Minimum = float64(v8)
1451 x.Minimum = float64(v8)
1453 x.Minimum = float64(v8)
1455 x.Minimum = float64(v8)
1457 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v8, v8)
1458 errors = append(errors, compiler.NewError(context, message))
1461 // bool exclusive_minimum = 9;
1462 v9 := compiler.MapValueForKey(m, "exclusiveMinimum")
1464 x.ExclusiveMinimum, ok = v9.(bool)
1466 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v9, v9)
1467 errors = append(errors, compiler.NewError(context, message))
1470 // int64 max_length = 10;
1471 v10 := compiler.MapValueForKey(m, "maxLength")
1475 x.MaxLength = int64(t)
1477 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v10, v10)
1478 errors = append(errors, compiler.NewError(context, message))
1481 // int64 min_length = 11;
1482 v11 := compiler.MapValueForKey(m, "minLength")
1486 x.MinLength = int64(t)
1488 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v11, v11)
1489 errors = append(errors, compiler.NewError(context, message))
1492 // string pattern = 12;
1493 v12 := compiler.MapValueForKey(m, "pattern")
1495 x.Pattern, ok = v12.(string)
1497 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v12, v12)
1498 errors = append(errors, compiler.NewError(context, message))
1501 // int64 max_items = 13;
1502 v13 := compiler.MapValueForKey(m, "maxItems")
1506 x.MaxItems = int64(t)
1508 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v13, v13)
1509 errors = append(errors, compiler.NewError(context, message))
1512 // int64 min_items = 14;
1513 v14 := compiler.MapValueForKey(m, "minItems")
1517 x.MinItems = int64(t)
1519 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v14, v14)
1520 errors = append(errors, compiler.NewError(context, message))
1523 // bool unique_items = 15;
1524 v15 := compiler.MapValueForKey(m, "uniqueItems")
1526 x.UniqueItems, ok = v15.(bool)
1528 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v15, v15)
1529 errors = append(errors, compiler.NewError(context, message))
1532 // repeated Any enum = 16;
1533 v16 := compiler.MapValueForKey(m, "enum")
1536 x.Enum = make([]*Any, 0)
1537 a, ok := v16.([]interface{})
1539 for _, item := range a {
1540 y, err := NewAny(item, compiler.NewContext("enum", context))
1542 errors = append(errors, err)
1544 x.Enum = append(x.Enum, y)
1548 // float multiple_of = 17;
1549 v17 := compiler.MapValueForKey(m, "multipleOf")
1551 switch v17 := v17.(type) {
1555 x.MultipleOf = float64(v17)
1557 x.MultipleOf = float64(v17)
1559 x.MultipleOf = float64(v17)
1561 x.MultipleOf = float64(v17)
1563 x.MultipleOf = float64(v17)
1565 x.MultipleOf = float64(v17)
1567 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v17, v17)
1568 errors = append(errors, compiler.NewError(context, message))
1571 // string description = 18;
1572 v18 := compiler.MapValueForKey(m, "description")
1574 x.Description, ok = v18.(string)
1576 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v18, v18)
1577 errors = append(errors, compiler.NewError(context, message))
1580 // repeated NamedAny vendor_extension = 19;
1582 x.VendorExtension = make([]*NamedAny, 0)
1583 for _, item := range m {
1584 k, ok := compiler.StringValue(item.Key)
1587 if strings.HasPrefix(k, "x-") {
1591 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
1594 errors = append(errors, err)
1596 bytes, _ := yaml.Marshal(v)
1597 result.Yaml = string(bytes)
1598 result.Value = resultFromExt
1602 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
1604 errors = append(errors, err)
1607 x.VendorExtension = append(x.VendorExtension, pair)
1612 return x, compiler.NewErrorGroupOrNil(errors)
1615 // NewHeaderParameterSubSchema creates an object of type HeaderParameterSubSchema if possible, returning an error if not.
1616 func NewHeaderParameterSubSchema(in interface{}, context *compiler.Context) (*HeaderParameterSubSchema, error) {
1617 errors := make([]error, 0)
1618 x := &HeaderParameterSubSchema{}
1619 m, ok := compiler.UnpackMap(in)
1621 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
1622 errors = append(errors, compiler.NewError(context, message))
1624 allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
1625 allowedPatterns := []*regexp.Regexp{pattern0}
1626 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
1627 if len(invalidKeys) > 0 {
1628 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
1629 errors = append(errors, compiler.NewError(context, message))
1631 // bool required = 1;
1632 v1 := compiler.MapValueForKey(m, "required")
1634 x.Required, ok = v1.(bool)
1636 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v1, v1)
1637 errors = append(errors, compiler.NewError(context, message))
1641 v2 := compiler.MapValueForKey(m, "in")
1643 x.In, ok = v2.(string)
1645 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
1646 errors = append(errors, compiler.NewError(context, message))
1648 // check for valid enum values
1650 if ok && !compiler.StringArrayContainsValue([]string{"header"}, x.In) {
1651 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
1652 errors = append(errors, compiler.NewError(context, message))
1655 // string description = 3;
1656 v3 := compiler.MapValueForKey(m, "description")
1658 x.Description, ok = v3.(string)
1660 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
1661 errors = append(errors, compiler.NewError(context, message))
1665 v4 := compiler.MapValueForKey(m, "name")
1667 x.Name, ok = v4.(string)
1669 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v4, v4)
1670 errors = append(errors, compiler.NewError(context, message))
1674 v5 := compiler.MapValueForKey(m, "type")
1676 x.Type, ok = v5.(string)
1678 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v5, v5)
1679 errors = append(errors, compiler.NewError(context, message))
1681 // check for valid enum values
1682 // [string number boolean integer array]
1683 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
1684 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v5, v5)
1685 errors = append(errors, compiler.NewError(context, message))
1688 // string format = 6;
1689 v6 := compiler.MapValueForKey(m, "format")
1691 x.Format, ok = v6.(string)
1693 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v6, v6)
1694 errors = append(errors, compiler.NewError(context, message))
1697 // PrimitivesItems items = 7;
1698 v7 := compiler.MapValueForKey(m, "items")
1701 x.Items, err = NewPrimitivesItems(v7, compiler.NewContext("items", context))
1703 errors = append(errors, err)
1706 // string collection_format = 8;
1707 v8 := compiler.MapValueForKey(m, "collectionFormat")
1709 x.CollectionFormat, ok = v8.(string)
1711 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v8, v8)
1712 errors = append(errors, compiler.NewError(context, message))
1714 // check for valid enum values
1715 // [csv ssv tsv pipes]
1716 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
1717 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v8, v8)
1718 errors = append(errors, compiler.NewError(context, message))
1722 v9 := compiler.MapValueForKey(m, "default")
1725 x.Default, err = NewAny(v9, compiler.NewContext("default", context))
1727 errors = append(errors, err)
1730 // float maximum = 10;
1731 v10 := compiler.MapValueForKey(m, "maximum")
1733 switch v10 := v10.(type) {
1737 x.Maximum = float64(v10)
1739 x.Maximum = float64(v10)
1741 x.Maximum = float64(v10)
1743 x.Maximum = float64(v10)
1745 x.Maximum = float64(v10)
1747 x.Maximum = float64(v10)
1749 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v10, v10)
1750 errors = append(errors, compiler.NewError(context, message))
1753 // bool exclusive_maximum = 11;
1754 v11 := compiler.MapValueForKey(m, "exclusiveMaximum")
1756 x.ExclusiveMaximum, ok = v11.(bool)
1758 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v11, v11)
1759 errors = append(errors, compiler.NewError(context, message))
1762 // float minimum = 12;
1763 v12 := compiler.MapValueForKey(m, "minimum")
1765 switch v12 := v12.(type) {
1769 x.Minimum = float64(v12)
1771 x.Minimum = float64(v12)
1773 x.Minimum = float64(v12)
1775 x.Minimum = float64(v12)
1777 x.Minimum = float64(v12)
1779 x.Minimum = float64(v12)
1781 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v12, v12)
1782 errors = append(errors, compiler.NewError(context, message))
1785 // bool exclusive_minimum = 13;
1786 v13 := compiler.MapValueForKey(m, "exclusiveMinimum")
1788 x.ExclusiveMinimum, ok = v13.(bool)
1790 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v13, v13)
1791 errors = append(errors, compiler.NewError(context, message))
1794 // int64 max_length = 14;
1795 v14 := compiler.MapValueForKey(m, "maxLength")
1799 x.MaxLength = int64(t)
1801 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v14, v14)
1802 errors = append(errors, compiler.NewError(context, message))
1805 // int64 min_length = 15;
1806 v15 := compiler.MapValueForKey(m, "minLength")
1810 x.MinLength = int64(t)
1812 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v15, v15)
1813 errors = append(errors, compiler.NewError(context, message))
1816 // string pattern = 16;
1817 v16 := compiler.MapValueForKey(m, "pattern")
1819 x.Pattern, ok = v16.(string)
1821 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v16, v16)
1822 errors = append(errors, compiler.NewError(context, message))
1825 // int64 max_items = 17;
1826 v17 := compiler.MapValueForKey(m, "maxItems")
1830 x.MaxItems = int64(t)
1832 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v17, v17)
1833 errors = append(errors, compiler.NewError(context, message))
1836 // int64 min_items = 18;
1837 v18 := compiler.MapValueForKey(m, "minItems")
1841 x.MinItems = int64(t)
1843 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v18, v18)
1844 errors = append(errors, compiler.NewError(context, message))
1847 // bool unique_items = 19;
1848 v19 := compiler.MapValueForKey(m, "uniqueItems")
1850 x.UniqueItems, ok = v19.(bool)
1852 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v19, v19)
1853 errors = append(errors, compiler.NewError(context, message))
1856 // repeated Any enum = 20;
1857 v20 := compiler.MapValueForKey(m, "enum")
1860 x.Enum = make([]*Any, 0)
1861 a, ok := v20.([]interface{})
1863 for _, item := range a {
1864 y, err := NewAny(item, compiler.NewContext("enum", context))
1866 errors = append(errors, err)
1868 x.Enum = append(x.Enum, y)
1872 // float multiple_of = 21;
1873 v21 := compiler.MapValueForKey(m, "multipleOf")
1875 switch v21 := v21.(type) {
1879 x.MultipleOf = float64(v21)
1881 x.MultipleOf = float64(v21)
1883 x.MultipleOf = float64(v21)
1885 x.MultipleOf = float64(v21)
1887 x.MultipleOf = float64(v21)
1889 x.MultipleOf = float64(v21)
1891 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v21, v21)
1892 errors = append(errors, compiler.NewError(context, message))
1895 // repeated NamedAny vendor_extension = 22;
1897 x.VendorExtension = make([]*NamedAny, 0)
1898 for _, item := range m {
1899 k, ok := compiler.StringValue(item.Key)
1902 if strings.HasPrefix(k, "x-") {
1906 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
1909 errors = append(errors, err)
1911 bytes, _ := yaml.Marshal(v)
1912 result.Yaml = string(bytes)
1913 result.Value = resultFromExt
1917 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
1919 errors = append(errors, err)
1922 x.VendorExtension = append(x.VendorExtension, pair)
1927 return x, compiler.NewErrorGroupOrNil(errors)
1930 // NewHeaders creates an object of type Headers if possible, returning an error if not.
1931 func NewHeaders(in interface{}, context *compiler.Context) (*Headers, error) {
1932 errors := make([]error, 0)
1934 m, ok := compiler.UnpackMap(in)
1936 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
1937 errors = append(errors, compiler.NewError(context, message))
1939 // repeated NamedHeader additional_properties = 1;
1941 x.AdditionalProperties = make([]*NamedHeader, 0)
1942 for _, item := range m {
1943 k, ok := compiler.StringValue(item.Key)
1946 pair := &NamedHeader{}
1949 pair.Value, err = NewHeader(v, compiler.NewContext(k, context))
1951 errors = append(errors, err)
1953 x.AdditionalProperties = append(x.AdditionalProperties, pair)
1957 return x, compiler.NewErrorGroupOrNil(errors)
1960 // NewInfo creates an object of type Info if possible, returning an error if not.
1961 func NewInfo(in interface{}, context *compiler.Context) (*Info, error) {
1962 errors := make([]error, 0)
1964 m, ok := compiler.UnpackMap(in)
1966 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
1967 errors = append(errors, compiler.NewError(context, message))
1969 requiredKeys := []string{"title", "version"}
1970 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
1971 if len(missingKeys) > 0 {
1972 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
1973 errors = append(errors, compiler.NewError(context, message))
1975 allowedKeys := []string{"contact", "description", "license", "termsOfService", "title", "version"}
1976 allowedPatterns := []*regexp.Regexp{pattern0}
1977 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
1978 if len(invalidKeys) > 0 {
1979 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
1980 errors = append(errors, compiler.NewError(context, message))
1982 // string title = 1;
1983 v1 := compiler.MapValueForKey(m, "title")
1985 x.Title, ok = v1.(string)
1987 message := fmt.Sprintf("has unexpected value for title: %+v (%T)", v1, v1)
1988 errors = append(errors, compiler.NewError(context, message))
1991 // string version = 2;
1992 v2 := compiler.MapValueForKey(m, "version")
1994 x.Version, ok = v2.(string)
1996 message := fmt.Sprintf("has unexpected value for version: %+v (%T)", v2, v2)
1997 errors = append(errors, compiler.NewError(context, message))
2000 // string description = 3;
2001 v3 := compiler.MapValueForKey(m, "description")
2003 x.Description, ok = v3.(string)
2005 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
2006 errors = append(errors, compiler.NewError(context, message))
2009 // string terms_of_service = 4;
2010 v4 := compiler.MapValueForKey(m, "termsOfService")
2012 x.TermsOfService, ok = v4.(string)
2014 message := fmt.Sprintf("has unexpected value for termsOfService: %+v (%T)", v4, v4)
2015 errors = append(errors, compiler.NewError(context, message))
2018 // Contact contact = 5;
2019 v5 := compiler.MapValueForKey(m, "contact")
2022 x.Contact, err = NewContact(v5, compiler.NewContext("contact", context))
2024 errors = append(errors, err)
2027 // License license = 6;
2028 v6 := compiler.MapValueForKey(m, "license")
2031 x.License, err = NewLicense(v6, compiler.NewContext("license", context))
2033 errors = append(errors, err)
2036 // repeated NamedAny vendor_extension = 7;
2038 x.VendorExtension = make([]*NamedAny, 0)
2039 for _, item := range m {
2040 k, ok := compiler.StringValue(item.Key)
2043 if strings.HasPrefix(k, "x-") {
2047 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
2050 errors = append(errors, err)
2052 bytes, _ := yaml.Marshal(v)
2053 result.Yaml = string(bytes)
2054 result.Value = resultFromExt
2058 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
2060 errors = append(errors, err)
2063 x.VendorExtension = append(x.VendorExtension, pair)
2068 return x, compiler.NewErrorGroupOrNil(errors)
2071 // NewItemsItem creates an object of type ItemsItem if possible, returning an error if not.
2072 func NewItemsItem(in interface{}, context *compiler.Context) (*ItemsItem, error) {
2073 errors := make([]error, 0)
2075 m, ok := compiler.UnpackMap(in)
2077 message := fmt.Sprintf("has unexpected value for item array: %+v (%T)", in, in)
2078 errors = append(errors, compiler.NewError(context, message))
2080 x.Schema = make([]*Schema, 0)
2081 y, err := NewSchema(m, compiler.NewContext("<array>", context))
2085 x.Schema = append(x.Schema, y)
2087 return x, compiler.NewErrorGroupOrNil(errors)
2090 // NewJsonReference creates an object of type JsonReference if possible, returning an error if not.
2091 func NewJsonReference(in interface{}, context *compiler.Context) (*JsonReference, error) {
2092 errors := make([]error, 0)
2093 x := &JsonReference{}
2094 m, ok := compiler.UnpackMap(in)
2096 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2097 errors = append(errors, compiler.NewError(context, message))
2099 requiredKeys := []string{"$ref"}
2100 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2101 if len(missingKeys) > 0 {
2102 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2103 errors = append(errors, compiler.NewError(context, message))
2105 allowedKeys := []string{"$ref", "description"}
2106 var allowedPatterns []*regexp.Regexp
2107 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2108 if len(invalidKeys) > 0 {
2109 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2110 errors = append(errors, compiler.NewError(context, message))
2113 v1 := compiler.MapValueForKey(m, "$ref")
2115 x.XRef, ok = v1.(string)
2117 message := fmt.Sprintf("has unexpected value for $ref: %+v (%T)", v1, v1)
2118 errors = append(errors, compiler.NewError(context, message))
2121 // string description = 2;
2122 v2 := compiler.MapValueForKey(m, "description")
2124 x.Description, ok = v2.(string)
2126 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v2, v2)
2127 errors = append(errors, compiler.NewError(context, message))
2131 return x, compiler.NewErrorGroupOrNil(errors)
2134 // NewLicense creates an object of type License if possible, returning an error if not.
2135 func NewLicense(in interface{}, context *compiler.Context) (*License, error) {
2136 errors := make([]error, 0)
2138 m, ok := compiler.UnpackMap(in)
2140 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2141 errors = append(errors, compiler.NewError(context, message))
2143 requiredKeys := []string{"name"}
2144 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2145 if len(missingKeys) > 0 {
2146 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2147 errors = append(errors, compiler.NewError(context, message))
2149 allowedKeys := []string{"name", "url"}
2150 allowedPatterns := []*regexp.Regexp{pattern0}
2151 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2152 if len(invalidKeys) > 0 {
2153 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2154 errors = append(errors, compiler.NewError(context, message))
2157 v1 := compiler.MapValueForKey(m, "name")
2159 x.Name, ok = v1.(string)
2161 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2162 errors = append(errors, compiler.NewError(context, message))
2166 v2 := compiler.MapValueForKey(m, "url")
2168 x.Url, ok = v2.(string)
2170 message := fmt.Sprintf("has unexpected value for url: %+v (%T)", v2, v2)
2171 errors = append(errors, compiler.NewError(context, message))
2174 // repeated NamedAny vendor_extension = 3;
2176 x.VendorExtension = make([]*NamedAny, 0)
2177 for _, item := range m {
2178 k, ok := compiler.StringValue(item.Key)
2181 if strings.HasPrefix(k, "x-") {
2185 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
2188 errors = append(errors, err)
2190 bytes, _ := yaml.Marshal(v)
2191 result.Yaml = string(bytes)
2192 result.Value = resultFromExt
2196 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
2198 errors = append(errors, err)
2201 x.VendorExtension = append(x.VendorExtension, pair)
2206 return x, compiler.NewErrorGroupOrNil(errors)
2209 // NewNamedAny creates an object of type NamedAny if possible, returning an error if not.
2210 func NewNamedAny(in interface{}, context *compiler.Context) (*NamedAny, error) {
2211 errors := make([]error, 0)
2213 m, ok := compiler.UnpackMap(in)
2215 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2216 errors = append(errors, compiler.NewError(context, message))
2218 allowedKeys := []string{"name", "value"}
2219 var allowedPatterns []*regexp.Regexp
2220 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2221 if len(invalidKeys) > 0 {
2222 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2223 errors = append(errors, compiler.NewError(context, message))
2226 v1 := compiler.MapValueForKey(m, "name")
2228 x.Name, ok = v1.(string)
2230 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2231 errors = append(errors, compiler.NewError(context, message))
2235 v2 := compiler.MapValueForKey(m, "value")
2238 x.Value, err = NewAny(v2, compiler.NewContext("value", context))
2240 errors = append(errors, err)
2244 return x, compiler.NewErrorGroupOrNil(errors)
2247 // NewNamedHeader creates an object of type NamedHeader if possible, returning an error if not.
2248 func NewNamedHeader(in interface{}, context *compiler.Context) (*NamedHeader, error) {
2249 errors := make([]error, 0)
2251 m, ok := compiler.UnpackMap(in)
2253 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2254 errors = append(errors, compiler.NewError(context, message))
2256 allowedKeys := []string{"name", "value"}
2257 var allowedPatterns []*regexp.Regexp
2258 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2259 if len(invalidKeys) > 0 {
2260 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2261 errors = append(errors, compiler.NewError(context, message))
2264 v1 := compiler.MapValueForKey(m, "name")
2266 x.Name, ok = v1.(string)
2268 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2269 errors = append(errors, compiler.NewError(context, message))
2272 // Header value = 2;
2273 v2 := compiler.MapValueForKey(m, "value")
2276 x.Value, err = NewHeader(v2, compiler.NewContext("value", context))
2278 errors = append(errors, err)
2282 return x, compiler.NewErrorGroupOrNil(errors)
2285 // NewNamedParameter creates an object of type NamedParameter if possible, returning an error if not.
2286 func NewNamedParameter(in interface{}, context *compiler.Context) (*NamedParameter, error) {
2287 errors := make([]error, 0)
2288 x := &NamedParameter{}
2289 m, ok := compiler.UnpackMap(in)
2291 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2292 errors = append(errors, compiler.NewError(context, message))
2294 allowedKeys := []string{"name", "value"}
2295 var allowedPatterns []*regexp.Regexp
2296 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2297 if len(invalidKeys) > 0 {
2298 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2299 errors = append(errors, compiler.NewError(context, message))
2302 v1 := compiler.MapValueForKey(m, "name")
2304 x.Name, ok = v1.(string)
2306 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2307 errors = append(errors, compiler.NewError(context, message))
2310 // Parameter value = 2;
2311 v2 := compiler.MapValueForKey(m, "value")
2314 x.Value, err = NewParameter(v2, compiler.NewContext("value", context))
2316 errors = append(errors, err)
2320 return x, compiler.NewErrorGroupOrNil(errors)
2323 // NewNamedPathItem creates an object of type NamedPathItem if possible, returning an error if not.
2324 func NewNamedPathItem(in interface{}, context *compiler.Context) (*NamedPathItem, error) {
2325 errors := make([]error, 0)
2326 x := &NamedPathItem{}
2327 m, ok := compiler.UnpackMap(in)
2329 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2330 errors = append(errors, compiler.NewError(context, message))
2332 allowedKeys := []string{"name", "value"}
2333 var allowedPatterns []*regexp.Regexp
2334 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2335 if len(invalidKeys) > 0 {
2336 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2337 errors = append(errors, compiler.NewError(context, message))
2340 v1 := compiler.MapValueForKey(m, "name")
2342 x.Name, ok = v1.(string)
2344 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2345 errors = append(errors, compiler.NewError(context, message))
2348 // PathItem value = 2;
2349 v2 := compiler.MapValueForKey(m, "value")
2352 x.Value, err = NewPathItem(v2, compiler.NewContext("value", context))
2354 errors = append(errors, err)
2358 return x, compiler.NewErrorGroupOrNil(errors)
2361 // NewNamedResponse creates an object of type NamedResponse if possible, returning an error if not.
2362 func NewNamedResponse(in interface{}, context *compiler.Context) (*NamedResponse, error) {
2363 errors := make([]error, 0)
2364 x := &NamedResponse{}
2365 m, ok := compiler.UnpackMap(in)
2367 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2368 errors = append(errors, compiler.NewError(context, message))
2370 allowedKeys := []string{"name", "value"}
2371 var allowedPatterns []*regexp.Regexp
2372 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2373 if len(invalidKeys) > 0 {
2374 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2375 errors = append(errors, compiler.NewError(context, message))
2378 v1 := compiler.MapValueForKey(m, "name")
2380 x.Name, ok = v1.(string)
2382 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2383 errors = append(errors, compiler.NewError(context, message))
2386 // Response value = 2;
2387 v2 := compiler.MapValueForKey(m, "value")
2390 x.Value, err = NewResponse(v2, compiler.NewContext("value", context))
2392 errors = append(errors, err)
2396 return x, compiler.NewErrorGroupOrNil(errors)
2399 // NewNamedResponseValue creates an object of type NamedResponseValue if possible, returning an error if not.
2400 func NewNamedResponseValue(in interface{}, context *compiler.Context) (*NamedResponseValue, error) {
2401 errors := make([]error, 0)
2402 x := &NamedResponseValue{}
2403 m, ok := compiler.UnpackMap(in)
2405 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2406 errors = append(errors, compiler.NewError(context, message))
2408 allowedKeys := []string{"name", "value"}
2409 var allowedPatterns []*regexp.Regexp
2410 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2411 if len(invalidKeys) > 0 {
2412 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2413 errors = append(errors, compiler.NewError(context, message))
2416 v1 := compiler.MapValueForKey(m, "name")
2418 x.Name, ok = v1.(string)
2420 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2421 errors = append(errors, compiler.NewError(context, message))
2424 // ResponseValue value = 2;
2425 v2 := compiler.MapValueForKey(m, "value")
2428 x.Value, err = NewResponseValue(v2, compiler.NewContext("value", context))
2430 errors = append(errors, err)
2434 return x, compiler.NewErrorGroupOrNil(errors)
2437 // NewNamedSchema creates an object of type NamedSchema if possible, returning an error if not.
2438 func NewNamedSchema(in interface{}, context *compiler.Context) (*NamedSchema, error) {
2439 errors := make([]error, 0)
2441 m, ok := compiler.UnpackMap(in)
2443 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2444 errors = append(errors, compiler.NewError(context, message))
2446 allowedKeys := []string{"name", "value"}
2447 var allowedPatterns []*regexp.Regexp
2448 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2449 if len(invalidKeys) > 0 {
2450 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2451 errors = append(errors, compiler.NewError(context, message))
2454 v1 := compiler.MapValueForKey(m, "name")
2456 x.Name, ok = v1.(string)
2458 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2459 errors = append(errors, compiler.NewError(context, message))
2462 // Schema value = 2;
2463 v2 := compiler.MapValueForKey(m, "value")
2466 x.Value, err = NewSchema(v2, compiler.NewContext("value", context))
2468 errors = append(errors, err)
2472 return x, compiler.NewErrorGroupOrNil(errors)
2475 // NewNamedSecurityDefinitionsItem creates an object of type NamedSecurityDefinitionsItem if possible, returning an error if not.
2476 func NewNamedSecurityDefinitionsItem(in interface{}, context *compiler.Context) (*NamedSecurityDefinitionsItem, error) {
2477 errors := make([]error, 0)
2478 x := &NamedSecurityDefinitionsItem{}
2479 m, ok := compiler.UnpackMap(in)
2481 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2482 errors = append(errors, compiler.NewError(context, message))
2484 allowedKeys := []string{"name", "value"}
2485 var allowedPatterns []*regexp.Regexp
2486 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2487 if len(invalidKeys) > 0 {
2488 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2489 errors = append(errors, compiler.NewError(context, message))
2492 v1 := compiler.MapValueForKey(m, "name")
2494 x.Name, ok = v1.(string)
2496 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2497 errors = append(errors, compiler.NewError(context, message))
2500 // SecurityDefinitionsItem value = 2;
2501 v2 := compiler.MapValueForKey(m, "value")
2504 x.Value, err = NewSecurityDefinitionsItem(v2, compiler.NewContext("value", context))
2506 errors = append(errors, err)
2510 return x, compiler.NewErrorGroupOrNil(errors)
2513 // NewNamedString creates an object of type NamedString if possible, returning an error if not.
2514 func NewNamedString(in interface{}, context *compiler.Context) (*NamedString, error) {
2515 errors := make([]error, 0)
2517 m, ok := compiler.UnpackMap(in)
2519 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2520 errors = append(errors, compiler.NewError(context, message))
2522 allowedKeys := []string{"name", "value"}
2523 var allowedPatterns []*regexp.Regexp
2524 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2525 if len(invalidKeys) > 0 {
2526 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2527 errors = append(errors, compiler.NewError(context, message))
2530 v1 := compiler.MapValueForKey(m, "name")
2532 x.Name, ok = v1.(string)
2534 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2535 errors = append(errors, compiler.NewError(context, message))
2538 // string value = 2;
2539 v2 := compiler.MapValueForKey(m, "value")
2541 x.Value, ok = v2.(string)
2543 message := fmt.Sprintf("has unexpected value for value: %+v (%T)", v2, v2)
2544 errors = append(errors, compiler.NewError(context, message))
2548 return x, compiler.NewErrorGroupOrNil(errors)
2551 // NewNamedStringArray creates an object of type NamedStringArray if possible, returning an error if not.
2552 func NewNamedStringArray(in interface{}, context *compiler.Context) (*NamedStringArray, error) {
2553 errors := make([]error, 0)
2554 x := &NamedStringArray{}
2555 m, ok := compiler.UnpackMap(in)
2557 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2558 errors = append(errors, compiler.NewError(context, message))
2560 allowedKeys := []string{"name", "value"}
2561 var allowedPatterns []*regexp.Regexp
2562 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2563 if len(invalidKeys) > 0 {
2564 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2565 errors = append(errors, compiler.NewError(context, message))
2568 v1 := compiler.MapValueForKey(m, "name")
2570 x.Name, ok = v1.(string)
2572 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
2573 errors = append(errors, compiler.NewError(context, message))
2576 // StringArray value = 2;
2577 v2 := compiler.MapValueForKey(m, "value")
2580 x.Value, err = NewStringArray(v2, compiler.NewContext("value", context))
2582 errors = append(errors, err)
2586 return x, compiler.NewErrorGroupOrNil(errors)
2589 // NewNonBodyParameter creates an object of type NonBodyParameter if possible, returning an error if not.
2590 func NewNonBodyParameter(in interface{}, context *compiler.Context) (*NonBodyParameter, error) {
2591 errors := make([]error, 0)
2592 x := &NonBodyParameter{}
2594 m, ok := compiler.UnpackMap(in)
2596 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2597 errors = append(errors, compiler.NewError(context, message))
2599 requiredKeys := []string{"in", "name", "type"}
2600 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2601 if len(missingKeys) > 0 {
2602 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2603 errors = append(errors, compiler.NewError(context, message))
2605 // HeaderParameterSubSchema header_parameter_sub_schema = 1;
2607 // errors might be ok here, they mean we just don't have the right subtype
2608 t, matchingError := NewHeaderParameterSubSchema(m, compiler.NewContext("headerParameterSubSchema", context))
2609 if matchingError == nil {
2610 x.Oneof = &NonBodyParameter_HeaderParameterSubSchema{HeaderParameterSubSchema: t}
2613 errors = append(errors, matchingError)
2616 // FormDataParameterSubSchema form_data_parameter_sub_schema = 2;
2618 // errors might be ok here, they mean we just don't have the right subtype
2619 t, matchingError := NewFormDataParameterSubSchema(m, compiler.NewContext("formDataParameterSubSchema", context))
2620 if matchingError == nil {
2621 x.Oneof = &NonBodyParameter_FormDataParameterSubSchema{FormDataParameterSubSchema: t}
2624 errors = append(errors, matchingError)
2627 // QueryParameterSubSchema query_parameter_sub_schema = 3;
2629 // errors might be ok here, they mean we just don't have the right subtype
2630 t, matchingError := NewQueryParameterSubSchema(m, compiler.NewContext("queryParameterSubSchema", context))
2631 if matchingError == nil {
2632 x.Oneof = &NonBodyParameter_QueryParameterSubSchema{QueryParameterSubSchema: t}
2635 errors = append(errors, matchingError)
2638 // PathParameterSubSchema path_parameter_sub_schema = 4;
2640 // errors might be ok here, they mean we just don't have the right subtype
2641 t, matchingError := NewPathParameterSubSchema(m, compiler.NewContext("pathParameterSubSchema", context))
2642 if matchingError == nil {
2643 x.Oneof = &NonBodyParameter_PathParameterSubSchema{PathParameterSubSchema: t}
2646 errors = append(errors, matchingError)
2651 // since the oneof matched one of its possibilities, discard any matching errors
2652 errors = make([]error, 0)
2654 return x, compiler.NewErrorGroupOrNil(errors)
2657 // NewOauth2AccessCodeSecurity creates an object of type Oauth2AccessCodeSecurity if possible, returning an error if not.
2658 func NewOauth2AccessCodeSecurity(in interface{}, context *compiler.Context) (*Oauth2AccessCodeSecurity, error) {
2659 errors := make([]error, 0)
2660 x := &Oauth2AccessCodeSecurity{}
2661 m, ok := compiler.UnpackMap(in)
2663 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2664 errors = append(errors, compiler.NewError(context, message))
2666 requiredKeys := []string{"authorizationUrl", "flow", "tokenUrl", "type"}
2667 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2668 if len(missingKeys) > 0 {
2669 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2670 errors = append(errors, compiler.NewError(context, message))
2672 allowedKeys := []string{"authorizationUrl", "description", "flow", "scopes", "tokenUrl", "type"}
2673 allowedPatterns := []*regexp.Regexp{pattern0}
2674 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2675 if len(invalidKeys) > 0 {
2676 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2677 errors = append(errors, compiler.NewError(context, message))
2680 v1 := compiler.MapValueForKey(m, "type")
2682 x.Type, ok = v1.(string)
2684 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2685 errors = append(errors, compiler.NewError(context, message))
2687 // check for valid enum values
2689 if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
2690 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2691 errors = append(errors, compiler.NewError(context, message))
2695 v2 := compiler.MapValueForKey(m, "flow")
2697 x.Flow, ok = v2.(string)
2699 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2700 errors = append(errors, compiler.NewError(context, message))
2702 // check for valid enum values
2704 if ok && !compiler.StringArrayContainsValue([]string{"accessCode"}, x.Flow) {
2705 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2706 errors = append(errors, compiler.NewError(context, message))
2709 // Oauth2Scopes scopes = 3;
2710 v3 := compiler.MapValueForKey(m, "scopes")
2713 x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", context))
2715 errors = append(errors, err)
2718 // string authorization_url = 4;
2719 v4 := compiler.MapValueForKey(m, "authorizationUrl")
2721 x.AuthorizationUrl, ok = v4.(string)
2723 message := fmt.Sprintf("has unexpected value for authorizationUrl: %+v (%T)", v4, v4)
2724 errors = append(errors, compiler.NewError(context, message))
2727 // string token_url = 5;
2728 v5 := compiler.MapValueForKey(m, "tokenUrl")
2730 x.TokenUrl, ok = v5.(string)
2732 message := fmt.Sprintf("has unexpected value for tokenUrl: %+v (%T)", v5, v5)
2733 errors = append(errors, compiler.NewError(context, message))
2736 // string description = 6;
2737 v6 := compiler.MapValueForKey(m, "description")
2739 x.Description, ok = v6.(string)
2741 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v6, v6)
2742 errors = append(errors, compiler.NewError(context, message))
2745 // repeated NamedAny vendor_extension = 7;
2747 x.VendorExtension = make([]*NamedAny, 0)
2748 for _, item := range m {
2749 k, ok := compiler.StringValue(item.Key)
2752 if strings.HasPrefix(k, "x-") {
2756 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
2759 errors = append(errors, err)
2761 bytes, _ := yaml.Marshal(v)
2762 result.Yaml = string(bytes)
2763 result.Value = resultFromExt
2767 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
2769 errors = append(errors, err)
2772 x.VendorExtension = append(x.VendorExtension, pair)
2777 return x, compiler.NewErrorGroupOrNil(errors)
2780 // NewOauth2ApplicationSecurity creates an object of type Oauth2ApplicationSecurity if possible, returning an error if not.
2781 func NewOauth2ApplicationSecurity(in interface{}, context *compiler.Context) (*Oauth2ApplicationSecurity, error) {
2782 errors := make([]error, 0)
2783 x := &Oauth2ApplicationSecurity{}
2784 m, ok := compiler.UnpackMap(in)
2786 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2787 errors = append(errors, compiler.NewError(context, message))
2789 requiredKeys := []string{"flow", "tokenUrl", "type"}
2790 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2791 if len(missingKeys) > 0 {
2792 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2793 errors = append(errors, compiler.NewError(context, message))
2795 allowedKeys := []string{"description", "flow", "scopes", "tokenUrl", "type"}
2796 allowedPatterns := []*regexp.Regexp{pattern0}
2797 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2798 if len(invalidKeys) > 0 {
2799 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2800 errors = append(errors, compiler.NewError(context, message))
2803 v1 := compiler.MapValueForKey(m, "type")
2805 x.Type, ok = v1.(string)
2807 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2808 errors = append(errors, compiler.NewError(context, message))
2810 // check for valid enum values
2812 if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
2813 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2814 errors = append(errors, compiler.NewError(context, message))
2818 v2 := compiler.MapValueForKey(m, "flow")
2820 x.Flow, ok = v2.(string)
2822 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2823 errors = append(errors, compiler.NewError(context, message))
2825 // check for valid enum values
2827 if ok && !compiler.StringArrayContainsValue([]string{"application"}, x.Flow) {
2828 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2829 errors = append(errors, compiler.NewError(context, message))
2832 // Oauth2Scopes scopes = 3;
2833 v3 := compiler.MapValueForKey(m, "scopes")
2836 x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", context))
2838 errors = append(errors, err)
2841 // string token_url = 4;
2842 v4 := compiler.MapValueForKey(m, "tokenUrl")
2844 x.TokenUrl, ok = v4.(string)
2846 message := fmt.Sprintf("has unexpected value for tokenUrl: %+v (%T)", v4, v4)
2847 errors = append(errors, compiler.NewError(context, message))
2850 // string description = 5;
2851 v5 := compiler.MapValueForKey(m, "description")
2853 x.Description, ok = v5.(string)
2855 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v5, v5)
2856 errors = append(errors, compiler.NewError(context, message))
2859 // repeated NamedAny vendor_extension = 6;
2861 x.VendorExtension = make([]*NamedAny, 0)
2862 for _, item := range m {
2863 k, ok := compiler.StringValue(item.Key)
2866 if strings.HasPrefix(k, "x-") {
2870 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
2873 errors = append(errors, err)
2875 bytes, _ := yaml.Marshal(v)
2876 result.Yaml = string(bytes)
2877 result.Value = resultFromExt
2881 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
2883 errors = append(errors, err)
2886 x.VendorExtension = append(x.VendorExtension, pair)
2891 return x, compiler.NewErrorGroupOrNil(errors)
2894 // NewOauth2ImplicitSecurity creates an object of type Oauth2ImplicitSecurity if possible, returning an error if not.
2895 func NewOauth2ImplicitSecurity(in interface{}, context *compiler.Context) (*Oauth2ImplicitSecurity, error) {
2896 errors := make([]error, 0)
2897 x := &Oauth2ImplicitSecurity{}
2898 m, ok := compiler.UnpackMap(in)
2900 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
2901 errors = append(errors, compiler.NewError(context, message))
2903 requiredKeys := []string{"authorizationUrl", "flow", "type"}
2904 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
2905 if len(missingKeys) > 0 {
2906 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
2907 errors = append(errors, compiler.NewError(context, message))
2909 allowedKeys := []string{"authorizationUrl", "description", "flow", "scopes", "type"}
2910 allowedPatterns := []*regexp.Regexp{pattern0}
2911 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
2912 if len(invalidKeys) > 0 {
2913 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
2914 errors = append(errors, compiler.NewError(context, message))
2917 v1 := compiler.MapValueForKey(m, "type")
2919 x.Type, ok = v1.(string)
2921 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2922 errors = append(errors, compiler.NewError(context, message))
2924 // check for valid enum values
2926 if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
2927 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
2928 errors = append(errors, compiler.NewError(context, message))
2932 v2 := compiler.MapValueForKey(m, "flow")
2934 x.Flow, ok = v2.(string)
2936 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2937 errors = append(errors, compiler.NewError(context, message))
2939 // check for valid enum values
2941 if ok && !compiler.StringArrayContainsValue([]string{"implicit"}, x.Flow) {
2942 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
2943 errors = append(errors, compiler.NewError(context, message))
2946 // Oauth2Scopes scopes = 3;
2947 v3 := compiler.MapValueForKey(m, "scopes")
2950 x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", context))
2952 errors = append(errors, err)
2955 // string authorization_url = 4;
2956 v4 := compiler.MapValueForKey(m, "authorizationUrl")
2958 x.AuthorizationUrl, ok = v4.(string)
2960 message := fmt.Sprintf("has unexpected value for authorizationUrl: %+v (%T)", v4, v4)
2961 errors = append(errors, compiler.NewError(context, message))
2964 // string description = 5;
2965 v5 := compiler.MapValueForKey(m, "description")
2967 x.Description, ok = v5.(string)
2969 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v5, v5)
2970 errors = append(errors, compiler.NewError(context, message))
2973 // repeated NamedAny vendor_extension = 6;
2975 x.VendorExtension = make([]*NamedAny, 0)
2976 for _, item := range m {
2977 k, ok := compiler.StringValue(item.Key)
2980 if strings.HasPrefix(k, "x-") {
2984 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
2987 errors = append(errors, err)
2989 bytes, _ := yaml.Marshal(v)
2990 result.Yaml = string(bytes)
2991 result.Value = resultFromExt
2995 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
2997 errors = append(errors, err)
3000 x.VendorExtension = append(x.VendorExtension, pair)
3005 return x, compiler.NewErrorGroupOrNil(errors)
3008 // NewOauth2PasswordSecurity creates an object of type Oauth2PasswordSecurity if possible, returning an error if not.
3009 func NewOauth2PasswordSecurity(in interface{}, context *compiler.Context) (*Oauth2PasswordSecurity, error) {
3010 errors := make([]error, 0)
3011 x := &Oauth2PasswordSecurity{}
3012 m, ok := compiler.UnpackMap(in)
3014 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3015 errors = append(errors, compiler.NewError(context, message))
3017 requiredKeys := []string{"flow", "tokenUrl", "type"}
3018 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
3019 if len(missingKeys) > 0 {
3020 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
3021 errors = append(errors, compiler.NewError(context, message))
3023 allowedKeys := []string{"description", "flow", "scopes", "tokenUrl", "type"}
3024 allowedPatterns := []*regexp.Regexp{pattern0}
3025 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3026 if len(invalidKeys) > 0 {
3027 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3028 errors = append(errors, compiler.NewError(context, message))
3031 v1 := compiler.MapValueForKey(m, "type")
3033 x.Type, ok = v1.(string)
3035 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
3036 errors = append(errors, compiler.NewError(context, message))
3038 // check for valid enum values
3040 if ok && !compiler.StringArrayContainsValue([]string{"oauth2"}, x.Type) {
3041 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
3042 errors = append(errors, compiler.NewError(context, message))
3046 v2 := compiler.MapValueForKey(m, "flow")
3048 x.Flow, ok = v2.(string)
3050 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
3051 errors = append(errors, compiler.NewError(context, message))
3053 // check for valid enum values
3055 if ok && !compiler.StringArrayContainsValue([]string{"password"}, x.Flow) {
3056 message := fmt.Sprintf("has unexpected value for flow: %+v (%T)", v2, v2)
3057 errors = append(errors, compiler.NewError(context, message))
3060 // Oauth2Scopes scopes = 3;
3061 v3 := compiler.MapValueForKey(m, "scopes")
3064 x.Scopes, err = NewOauth2Scopes(v3, compiler.NewContext("scopes", context))
3066 errors = append(errors, err)
3069 // string token_url = 4;
3070 v4 := compiler.MapValueForKey(m, "tokenUrl")
3072 x.TokenUrl, ok = v4.(string)
3074 message := fmt.Sprintf("has unexpected value for tokenUrl: %+v (%T)", v4, v4)
3075 errors = append(errors, compiler.NewError(context, message))
3078 // string description = 5;
3079 v5 := compiler.MapValueForKey(m, "description")
3081 x.Description, ok = v5.(string)
3083 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v5, v5)
3084 errors = append(errors, compiler.NewError(context, message))
3087 // repeated NamedAny vendor_extension = 6;
3089 x.VendorExtension = make([]*NamedAny, 0)
3090 for _, item := range m {
3091 k, ok := compiler.StringValue(item.Key)
3094 if strings.HasPrefix(k, "x-") {
3098 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
3101 errors = append(errors, err)
3103 bytes, _ := yaml.Marshal(v)
3104 result.Yaml = string(bytes)
3105 result.Value = resultFromExt
3109 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
3111 errors = append(errors, err)
3114 x.VendorExtension = append(x.VendorExtension, pair)
3119 return x, compiler.NewErrorGroupOrNil(errors)
3122 // NewOauth2Scopes creates an object of type Oauth2Scopes if possible, returning an error if not.
3123 func NewOauth2Scopes(in interface{}, context *compiler.Context) (*Oauth2Scopes, error) {
3124 errors := make([]error, 0)
3125 x := &Oauth2Scopes{}
3126 m, ok := compiler.UnpackMap(in)
3128 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3129 errors = append(errors, compiler.NewError(context, message))
3131 // repeated NamedString additional_properties = 1;
3133 x.AdditionalProperties = make([]*NamedString, 0)
3134 for _, item := range m {
3135 k, ok := compiler.StringValue(item.Key)
3138 pair := &NamedString{}
3140 pair.Value = v.(string)
3141 x.AdditionalProperties = append(x.AdditionalProperties, pair)
3145 return x, compiler.NewErrorGroupOrNil(errors)
3148 // NewOperation creates an object of type Operation if possible, returning an error if not.
3149 func NewOperation(in interface{}, context *compiler.Context) (*Operation, error) {
3150 errors := make([]error, 0)
3152 m, ok := compiler.UnpackMap(in)
3154 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3155 errors = append(errors, compiler.NewError(context, message))
3157 requiredKeys := []string{"responses"}
3158 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
3159 if len(missingKeys) > 0 {
3160 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
3161 errors = append(errors, compiler.NewError(context, message))
3163 allowedKeys := []string{"consumes", "deprecated", "description", "externalDocs", "operationId", "parameters", "produces", "responses", "schemes", "security", "summary", "tags"}
3164 allowedPatterns := []*regexp.Regexp{pattern0}
3165 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3166 if len(invalidKeys) > 0 {
3167 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3168 errors = append(errors, compiler.NewError(context, message))
3170 // repeated string tags = 1;
3171 v1 := compiler.MapValueForKey(m, "tags")
3173 v, ok := v1.([]interface{})
3175 x.Tags = compiler.ConvertInterfaceArrayToStringArray(v)
3177 message := fmt.Sprintf("has unexpected value for tags: %+v (%T)", v1, v1)
3178 errors = append(errors, compiler.NewError(context, message))
3181 // string summary = 2;
3182 v2 := compiler.MapValueForKey(m, "summary")
3184 x.Summary, ok = v2.(string)
3186 message := fmt.Sprintf("has unexpected value for summary: %+v (%T)", v2, v2)
3187 errors = append(errors, compiler.NewError(context, message))
3190 // string description = 3;
3191 v3 := compiler.MapValueForKey(m, "description")
3193 x.Description, ok = v3.(string)
3195 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
3196 errors = append(errors, compiler.NewError(context, message))
3199 // ExternalDocs external_docs = 4;
3200 v4 := compiler.MapValueForKey(m, "externalDocs")
3203 x.ExternalDocs, err = NewExternalDocs(v4, compiler.NewContext("externalDocs", context))
3205 errors = append(errors, err)
3208 // string operation_id = 5;
3209 v5 := compiler.MapValueForKey(m, "operationId")
3211 x.OperationId, ok = v5.(string)
3213 message := fmt.Sprintf("has unexpected value for operationId: %+v (%T)", v5, v5)
3214 errors = append(errors, compiler.NewError(context, message))
3217 // repeated string produces = 6;
3218 v6 := compiler.MapValueForKey(m, "produces")
3220 v, ok := v6.([]interface{})
3222 x.Produces = compiler.ConvertInterfaceArrayToStringArray(v)
3224 message := fmt.Sprintf("has unexpected value for produces: %+v (%T)", v6, v6)
3225 errors = append(errors, compiler.NewError(context, message))
3228 // repeated string consumes = 7;
3229 v7 := compiler.MapValueForKey(m, "consumes")
3231 v, ok := v7.([]interface{})
3233 x.Consumes = compiler.ConvertInterfaceArrayToStringArray(v)
3235 message := fmt.Sprintf("has unexpected value for consumes: %+v (%T)", v7, v7)
3236 errors = append(errors, compiler.NewError(context, message))
3239 // repeated ParametersItem parameters = 8;
3240 v8 := compiler.MapValueForKey(m, "parameters")
3242 // repeated ParametersItem
3243 x.Parameters = make([]*ParametersItem, 0)
3244 a, ok := v8.([]interface{})
3246 for _, item := range a {
3247 y, err := NewParametersItem(item, compiler.NewContext("parameters", context))
3249 errors = append(errors, err)
3251 x.Parameters = append(x.Parameters, y)
3255 // Responses responses = 9;
3256 v9 := compiler.MapValueForKey(m, "responses")
3259 x.Responses, err = NewResponses(v9, compiler.NewContext("responses", context))
3261 errors = append(errors, err)
3264 // repeated string schemes = 10;
3265 v10 := compiler.MapValueForKey(m, "schemes")
3267 v, ok := v10.([]interface{})
3269 x.Schemes = compiler.ConvertInterfaceArrayToStringArray(v)
3271 message := fmt.Sprintf("has unexpected value for schemes: %+v (%T)", v10, v10)
3272 errors = append(errors, compiler.NewError(context, message))
3274 // check for valid enum values
3275 // [http https ws wss]
3276 if ok && !compiler.StringArrayContainsValues([]string{"http", "https", "ws", "wss"}, x.Schemes) {
3277 message := fmt.Sprintf("has unexpected value for schemes: %+v", v10)
3278 errors = append(errors, compiler.NewError(context, message))
3281 // bool deprecated = 11;
3282 v11 := compiler.MapValueForKey(m, "deprecated")
3284 x.Deprecated, ok = v11.(bool)
3286 message := fmt.Sprintf("has unexpected value for deprecated: %+v (%T)", v11, v11)
3287 errors = append(errors, compiler.NewError(context, message))
3290 // repeated SecurityRequirement security = 12;
3291 v12 := compiler.MapValueForKey(m, "security")
3293 // repeated SecurityRequirement
3294 x.Security = make([]*SecurityRequirement, 0)
3295 a, ok := v12.([]interface{})
3297 for _, item := range a {
3298 y, err := NewSecurityRequirement(item, compiler.NewContext("security", context))
3300 errors = append(errors, err)
3302 x.Security = append(x.Security, y)
3306 // repeated NamedAny vendor_extension = 13;
3308 x.VendorExtension = make([]*NamedAny, 0)
3309 for _, item := range m {
3310 k, ok := compiler.StringValue(item.Key)
3313 if strings.HasPrefix(k, "x-") {
3317 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
3320 errors = append(errors, err)
3322 bytes, _ := yaml.Marshal(v)
3323 result.Yaml = string(bytes)
3324 result.Value = resultFromExt
3328 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
3330 errors = append(errors, err)
3333 x.VendorExtension = append(x.VendorExtension, pair)
3338 return x, compiler.NewErrorGroupOrNil(errors)
3341 // NewParameter creates an object of type Parameter if possible, returning an error if not.
3342 func NewParameter(in interface{}, context *compiler.Context) (*Parameter, error) {
3343 errors := make([]error, 0)
3346 // BodyParameter body_parameter = 1;
3348 m, ok := compiler.UnpackMap(in)
3350 // errors might be ok here, they mean we just don't have the right subtype
3351 t, matchingError := NewBodyParameter(m, compiler.NewContext("bodyParameter", context))
3352 if matchingError == nil {
3353 x.Oneof = &Parameter_BodyParameter{BodyParameter: t}
3356 errors = append(errors, matchingError)
3360 // NonBodyParameter non_body_parameter = 2;
3362 m, ok := compiler.UnpackMap(in)
3364 // errors might be ok here, they mean we just don't have the right subtype
3365 t, matchingError := NewNonBodyParameter(m, compiler.NewContext("nonBodyParameter", context))
3366 if matchingError == nil {
3367 x.Oneof = &Parameter_NonBodyParameter{NonBodyParameter: t}
3370 errors = append(errors, matchingError)
3375 // since the oneof matched one of its possibilities, discard any matching errors
3376 errors = make([]error, 0)
3378 return x, compiler.NewErrorGroupOrNil(errors)
3381 // NewParameterDefinitions creates an object of type ParameterDefinitions if possible, returning an error if not.
3382 func NewParameterDefinitions(in interface{}, context *compiler.Context) (*ParameterDefinitions, error) {
3383 errors := make([]error, 0)
3384 x := &ParameterDefinitions{}
3385 m, ok := compiler.UnpackMap(in)
3387 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3388 errors = append(errors, compiler.NewError(context, message))
3390 // repeated NamedParameter additional_properties = 1;
3392 x.AdditionalProperties = make([]*NamedParameter, 0)
3393 for _, item := range m {
3394 k, ok := compiler.StringValue(item.Key)
3397 pair := &NamedParameter{}
3400 pair.Value, err = NewParameter(v, compiler.NewContext(k, context))
3402 errors = append(errors, err)
3404 x.AdditionalProperties = append(x.AdditionalProperties, pair)
3408 return x, compiler.NewErrorGroupOrNil(errors)
3411 // NewParametersItem creates an object of type ParametersItem if possible, returning an error if not.
3412 func NewParametersItem(in interface{}, context *compiler.Context) (*ParametersItem, error) {
3413 errors := make([]error, 0)
3414 x := &ParametersItem{}
3416 // Parameter parameter = 1;
3418 m, ok := compiler.UnpackMap(in)
3420 // errors might be ok here, they mean we just don't have the right subtype
3421 t, matchingError := NewParameter(m, compiler.NewContext("parameter", context))
3422 if matchingError == nil {
3423 x.Oneof = &ParametersItem_Parameter{Parameter: t}
3426 errors = append(errors, matchingError)
3430 // JsonReference json_reference = 2;
3432 m, ok := compiler.UnpackMap(in)
3434 // errors might be ok here, they mean we just don't have the right subtype
3435 t, matchingError := NewJsonReference(m, compiler.NewContext("jsonReference", context))
3436 if matchingError == nil {
3437 x.Oneof = &ParametersItem_JsonReference{JsonReference: t}
3440 errors = append(errors, matchingError)
3445 // since the oneof matched one of its possibilities, discard any matching errors
3446 errors = make([]error, 0)
3448 return x, compiler.NewErrorGroupOrNil(errors)
3451 // NewPathItem creates an object of type PathItem if possible, returning an error if not.
3452 func NewPathItem(in interface{}, context *compiler.Context) (*PathItem, error) {
3453 errors := make([]error, 0)
3455 m, ok := compiler.UnpackMap(in)
3457 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3458 errors = append(errors, compiler.NewError(context, message))
3460 allowedKeys := []string{"$ref", "delete", "get", "head", "options", "parameters", "patch", "post", "put"}
3461 allowedPatterns := []*regexp.Regexp{pattern0}
3462 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3463 if len(invalidKeys) > 0 {
3464 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3465 errors = append(errors, compiler.NewError(context, message))
3468 v1 := compiler.MapValueForKey(m, "$ref")
3470 x.XRef, ok = v1.(string)
3472 message := fmt.Sprintf("has unexpected value for $ref: %+v (%T)", v1, v1)
3473 errors = append(errors, compiler.NewError(context, message))
3476 // Operation get = 2;
3477 v2 := compiler.MapValueForKey(m, "get")
3480 x.Get, err = NewOperation(v2, compiler.NewContext("get", context))
3482 errors = append(errors, err)
3485 // Operation put = 3;
3486 v3 := compiler.MapValueForKey(m, "put")
3489 x.Put, err = NewOperation(v3, compiler.NewContext("put", context))
3491 errors = append(errors, err)
3494 // Operation post = 4;
3495 v4 := compiler.MapValueForKey(m, "post")
3498 x.Post, err = NewOperation(v4, compiler.NewContext("post", context))
3500 errors = append(errors, err)
3503 // Operation delete = 5;
3504 v5 := compiler.MapValueForKey(m, "delete")
3507 x.Delete, err = NewOperation(v5, compiler.NewContext("delete", context))
3509 errors = append(errors, err)
3512 // Operation options = 6;
3513 v6 := compiler.MapValueForKey(m, "options")
3516 x.Options, err = NewOperation(v6, compiler.NewContext("options", context))
3518 errors = append(errors, err)
3521 // Operation head = 7;
3522 v7 := compiler.MapValueForKey(m, "head")
3525 x.Head, err = NewOperation(v7, compiler.NewContext("head", context))
3527 errors = append(errors, err)
3530 // Operation patch = 8;
3531 v8 := compiler.MapValueForKey(m, "patch")
3534 x.Patch, err = NewOperation(v8, compiler.NewContext("patch", context))
3536 errors = append(errors, err)
3539 // repeated ParametersItem parameters = 9;
3540 v9 := compiler.MapValueForKey(m, "parameters")
3542 // repeated ParametersItem
3543 x.Parameters = make([]*ParametersItem, 0)
3544 a, ok := v9.([]interface{})
3546 for _, item := range a {
3547 y, err := NewParametersItem(item, compiler.NewContext("parameters", context))
3549 errors = append(errors, err)
3551 x.Parameters = append(x.Parameters, y)
3555 // repeated NamedAny vendor_extension = 10;
3557 x.VendorExtension = make([]*NamedAny, 0)
3558 for _, item := range m {
3559 k, ok := compiler.StringValue(item.Key)
3562 if strings.HasPrefix(k, "x-") {
3566 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
3569 errors = append(errors, err)
3571 bytes, _ := yaml.Marshal(v)
3572 result.Yaml = string(bytes)
3573 result.Value = resultFromExt
3577 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
3579 errors = append(errors, err)
3582 x.VendorExtension = append(x.VendorExtension, pair)
3587 return x, compiler.NewErrorGroupOrNil(errors)
3590 // NewPathParameterSubSchema creates an object of type PathParameterSubSchema if possible, returning an error if not.
3591 func NewPathParameterSubSchema(in interface{}, context *compiler.Context) (*PathParameterSubSchema, error) {
3592 errors := make([]error, 0)
3593 x := &PathParameterSubSchema{}
3594 m, ok := compiler.UnpackMap(in)
3596 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3597 errors = append(errors, compiler.NewError(context, message))
3599 requiredKeys := []string{"required"}
3600 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
3601 if len(missingKeys) > 0 {
3602 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
3603 errors = append(errors, compiler.NewError(context, message))
3605 allowedKeys := []string{"collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
3606 allowedPatterns := []*regexp.Regexp{pattern0}
3607 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3608 if len(invalidKeys) > 0 {
3609 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3610 errors = append(errors, compiler.NewError(context, message))
3612 // bool required = 1;
3613 v1 := compiler.MapValueForKey(m, "required")
3615 x.Required, ok = v1.(bool)
3617 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v1, v1)
3618 errors = append(errors, compiler.NewError(context, message))
3622 v2 := compiler.MapValueForKey(m, "in")
3624 x.In, ok = v2.(string)
3626 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
3627 errors = append(errors, compiler.NewError(context, message))
3629 // check for valid enum values
3631 if ok && !compiler.StringArrayContainsValue([]string{"path"}, x.In) {
3632 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
3633 errors = append(errors, compiler.NewError(context, message))
3636 // string description = 3;
3637 v3 := compiler.MapValueForKey(m, "description")
3639 x.Description, ok = v3.(string)
3641 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
3642 errors = append(errors, compiler.NewError(context, message))
3646 v4 := compiler.MapValueForKey(m, "name")
3648 x.Name, ok = v4.(string)
3650 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v4, v4)
3651 errors = append(errors, compiler.NewError(context, message))
3655 v5 := compiler.MapValueForKey(m, "type")
3657 x.Type, ok = v5.(string)
3659 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v5, v5)
3660 errors = append(errors, compiler.NewError(context, message))
3662 // check for valid enum values
3663 // [string number boolean integer array]
3664 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
3665 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v5, v5)
3666 errors = append(errors, compiler.NewError(context, message))
3669 // string format = 6;
3670 v6 := compiler.MapValueForKey(m, "format")
3672 x.Format, ok = v6.(string)
3674 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v6, v6)
3675 errors = append(errors, compiler.NewError(context, message))
3678 // PrimitivesItems items = 7;
3679 v7 := compiler.MapValueForKey(m, "items")
3682 x.Items, err = NewPrimitivesItems(v7, compiler.NewContext("items", context))
3684 errors = append(errors, err)
3687 // string collection_format = 8;
3688 v8 := compiler.MapValueForKey(m, "collectionFormat")
3690 x.CollectionFormat, ok = v8.(string)
3692 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v8, v8)
3693 errors = append(errors, compiler.NewError(context, message))
3695 // check for valid enum values
3696 // [csv ssv tsv pipes]
3697 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
3698 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v8, v8)
3699 errors = append(errors, compiler.NewError(context, message))
3703 v9 := compiler.MapValueForKey(m, "default")
3706 x.Default, err = NewAny(v9, compiler.NewContext("default", context))
3708 errors = append(errors, err)
3711 // float maximum = 10;
3712 v10 := compiler.MapValueForKey(m, "maximum")
3714 switch v10 := v10.(type) {
3718 x.Maximum = float64(v10)
3720 x.Maximum = float64(v10)
3722 x.Maximum = float64(v10)
3724 x.Maximum = float64(v10)
3726 x.Maximum = float64(v10)
3728 x.Maximum = float64(v10)
3730 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v10, v10)
3731 errors = append(errors, compiler.NewError(context, message))
3734 // bool exclusive_maximum = 11;
3735 v11 := compiler.MapValueForKey(m, "exclusiveMaximum")
3737 x.ExclusiveMaximum, ok = v11.(bool)
3739 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v11, v11)
3740 errors = append(errors, compiler.NewError(context, message))
3743 // float minimum = 12;
3744 v12 := compiler.MapValueForKey(m, "minimum")
3746 switch v12 := v12.(type) {
3750 x.Minimum = float64(v12)
3752 x.Minimum = float64(v12)
3754 x.Minimum = float64(v12)
3756 x.Minimum = float64(v12)
3758 x.Minimum = float64(v12)
3760 x.Minimum = float64(v12)
3762 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v12, v12)
3763 errors = append(errors, compiler.NewError(context, message))
3766 // bool exclusive_minimum = 13;
3767 v13 := compiler.MapValueForKey(m, "exclusiveMinimum")
3769 x.ExclusiveMinimum, ok = v13.(bool)
3771 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v13, v13)
3772 errors = append(errors, compiler.NewError(context, message))
3775 // int64 max_length = 14;
3776 v14 := compiler.MapValueForKey(m, "maxLength")
3780 x.MaxLength = int64(t)
3782 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v14, v14)
3783 errors = append(errors, compiler.NewError(context, message))
3786 // int64 min_length = 15;
3787 v15 := compiler.MapValueForKey(m, "minLength")
3791 x.MinLength = int64(t)
3793 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v15, v15)
3794 errors = append(errors, compiler.NewError(context, message))
3797 // string pattern = 16;
3798 v16 := compiler.MapValueForKey(m, "pattern")
3800 x.Pattern, ok = v16.(string)
3802 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v16, v16)
3803 errors = append(errors, compiler.NewError(context, message))
3806 // int64 max_items = 17;
3807 v17 := compiler.MapValueForKey(m, "maxItems")
3811 x.MaxItems = int64(t)
3813 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v17, v17)
3814 errors = append(errors, compiler.NewError(context, message))
3817 // int64 min_items = 18;
3818 v18 := compiler.MapValueForKey(m, "minItems")
3822 x.MinItems = int64(t)
3824 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v18, v18)
3825 errors = append(errors, compiler.NewError(context, message))
3828 // bool unique_items = 19;
3829 v19 := compiler.MapValueForKey(m, "uniqueItems")
3831 x.UniqueItems, ok = v19.(bool)
3833 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v19, v19)
3834 errors = append(errors, compiler.NewError(context, message))
3837 // repeated Any enum = 20;
3838 v20 := compiler.MapValueForKey(m, "enum")
3841 x.Enum = make([]*Any, 0)
3842 a, ok := v20.([]interface{})
3844 for _, item := range a {
3845 y, err := NewAny(item, compiler.NewContext("enum", context))
3847 errors = append(errors, err)
3849 x.Enum = append(x.Enum, y)
3853 // float multiple_of = 21;
3854 v21 := compiler.MapValueForKey(m, "multipleOf")
3856 switch v21 := v21.(type) {
3860 x.MultipleOf = float64(v21)
3862 x.MultipleOf = float64(v21)
3864 x.MultipleOf = float64(v21)
3866 x.MultipleOf = float64(v21)
3868 x.MultipleOf = float64(v21)
3870 x.MultipleOf = float64(v21)
3872 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v21, v21)
3873 errors = append(errors, compiler.NewError(context, message))
3876 // repeated NamedAny vendor_extension = 22;
3878 x.VendorExtension = make([]*NamedAny, 0)
3879 for _, item := range m {
3880 k, ok := compiler.StringValue(item.Key)
3883 if strings.HasPrefix(k, "x-") {
3887 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
3890 errors = append(errors, err)
3892 bytes, _ := yaml.Marshal(v)
3893 result.Yaml = string(bytes)
3894 result.Value = resultFromExt
3898 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
3900 errors = append(errors, err)
3903 x.VendorExtension = append(x.VendorExtension, pair)
3908 return x, compiler.NewErrorGroupOrNil(errors)
3911 // NewPaths creates an object of type Paths if possible, returning an error if not.
3912 func NewPaths(in interface{}, context *compiler.Context) (*Paths, error) {
3913 errors := make([]error, 0)
3915 m, ok := compiler.UnpackMap(in)
3917 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3918 errors = append(errors, compiler.NewError(context, message))
3920 allowedKeys := []string{}
3921 allowedPatterns := []*regexp.Regexp{pattern0, pattern1}
3922 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3923 if len(invalidKeys) > 0 {
3924 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3925 errors = append(errors, compiler.NewError(context, message))
3927 // repeated NamedAny vendor_extension = 1;
3929 x.VendorExtension = make([]*NamedAny, 0)
3930 for _, item := range m {
3931 k, ok := compiler.StringValue(item.Key)
3934 if strings.HasPrefix(k, "x-") {
3938 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
3941 errors = append(errors, err)
3943 bytes, _ := yaml.Marshal(v)
3944 result.Yaml = string(bytes)
3945 result.Value = resultFromExt
3949 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
3951 errors = append(errors, err)
3954 x.VendorExtension = append(x.VendorExtension, pair)
3958 // repeated NamedPathItem path = 2;
3960 x.Path = make([]*NamedPathItem, 0)
3961 for _, item := range m {
3962 k, ok := compiler.StringValue(item.Key)
3965 if strings.HasPrefix(k, "/") {
3966 pair := &NamedPathItem{}
3969 pair.Value, err = NewPathItem(v, compiler.NewContext(k, context))
3971 errors = append(errors, err)
3973 x.Path = append(x.Path, pair)
3978 return x, compiler.NewErrorGroupOrNil(errors)
3981 // NewPrimitivesItems creates an object of type PrimitivesItems if possible, returning an error if not.
3982 func NewPrimitivesItems(in interface{}, context *compiler.Context) (*PrimitivesItems, error) {
3983 errors := make([]error, 0)
3984 x := &PrimitivesItems{}
3985 m, ok := compiler.UnpackMap(in)
3987 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
3988 errors = append(errors, compiler.NewError(context, message))
3990 allowedKeys := []string{"collectionFormat", "default", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "pattern", "type", "uniqueItems"}
3991 allowedPatterns := []*regexp.Regexp{pattern0}
3992 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
3993 if len(invalidKeys) > 0 {
3994 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
3995 errors = append(errors, compiler.NewError(context, message))
3998 v1 := compiler.MapValueForKey(m, "type")
4000 x.Type, ok = v1.(string)
4002 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
4003 errors = append(errors, compiler.NewError(context, message))
4005 // check for valid enum values
4006 // [string number integer boolean array]
4007 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "integer", "boolean", "array"}, x.Type) {
4008 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v1, v1)
4009 errors = append(errors, compiler.NewError(context, message))
4012 // string format = 2;
4013 v2 := compiler.MapValueForKey(m, "format")
4015 x.Format, ok = v2.(string)
4017 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v2, v2)
4018 errors = append(errors, compiler.NewError(context, message))
4021 // PrimitivesItems items = 3;
4022 v3 := compiler.MapValueForKey(m, "items")
4025 x.Items, err = NewPrimitivesItems(v3, compiler.NewContext("items", context))
4027 errors = append(errors, err)
4030 // string collection_format = 4;
4031 v4 := compiler.MapValueForKey(m, "collectionFormat")
4033 x.CollectionFormat, ok = v4.(string)
4035 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v4, v4)
4036 errors = append(errors, compiler.NewError(context, message))
4038 // check for valid enum values
4039 // [csv ssv tsv pipes]
4040 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes"}, x.CollectionFormat) {
4041 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v4, v4)
4042 errors = append(errors, compiler.NewError(context, message))
4046 v5 := compiler.MapValueForKey(m, "default")
4049 x.Default, err = NewAny(v5, compiler.NewContext("default", context))
4051 errors = append(errors, err)
4054 // float maximum = 6;
4055 v6 := compiler.MapValueForKey(m, "maximum")
4057 switch v6 := v6.(type) {
4061 x.Maximum = float64(v6)
4063 x.Maximum = float64(v6)
4065 x.Maximum = float64(v6)
4067 x.Maximum = float64(v6)
4069 x.Maximum = float64(v6)
4071 x.Maximum = float64(v6)
4073 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v6, v6)
4074 errors = append(errors, compiler.NewError(context, message))
4077 // bool exclusive_maximum = 7;
4078 v7 := compiler.MapValueForKey(m, "exclusiveMaximum")
4080 x.ExclusiveMaximum, ok = v7.(bool)
4082 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v7, v7)
4083 errors = append(errors, compiler.NewError(context, message))
4086 // float minimum = 8;
4087 v8 := compiler.MapValueForKey(m, "minimum")
4089 switch v8 := v8.(type) {
4093 x.Minimum = float64(v8)
4095 x.Minimum = float64(v8)
4097 x.Minimum = float64(v8)
4099 x.Minimum = float64(v8)
4101 x.Minimum = float64(v8)
4103 x.Minimum = float64(v8)
4105 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v8, v8)
4106 errors = append(errors, compiler.NewError(context, message))
4109 // bool exclusive_minimum = 9;
4110 v9 := compiler.MapValueForKey(m, "exclusiveMinimum")
4112 x.ExclusiveMinimum, ok = v9.(bool)
4114 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v9, v9)
4115 errors = append(errors, compiler.NewError(context, message))
4118 // int64 max_length = 10;
4119 v10 := compiler.MapValueForKey(m, "maxLength")
4123 x.MaxLength = int64(t)
4125 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v10, v10)
4126 errors = append(errors, compiler.NewError(context, message))
4129 // int64 min_length = 11;
4130 v11 := compiler.MapValueForKey(m, "minLength")
4134 x.MinLength = int64(t)
4136 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v11, v11)
4137 errors = append(errors, compiler.NewError(context, message))
4140 // string pattern = 12;
4141 v12 := compiler.MapValueForKey(m, "pattern")
4143 x.Pattern, ok = v12.(string)
4145 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v12, v12)
4146 errors = append(errors, compiler.NewError(context, message))
4149 // int64 max_items = 13;
4150 v13 := compiler.MapValueForKey(m, "maxItems")
4154 x.MaxItems = int64(t)
4156 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v13, v13)
4157 errors = append(errors, compiler.NewError(context, message))
4160 // int64 min_items = 14;
4161 v14 := compiler.MapValueForKey(m, "minItems")
4165 x.MinItems = int64(t)
4167 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v14, v14)
4168 errors = append(errors, compiler.NewError(context, message))
4171 // bool unique_items = 15;
4172 v15 := compiler.MapValueForKey(m, "uniqueItems")
4174 x.UniqueItems, ok = v15.(bool)
4176 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v15, v15)
4177 errors = append(errors, compiler.NewError(context, message))
4180 // repeated Any enum = 16;
4181 v16 := compiler.MapValueForKey(m, "enum")
4184 x.Enum = make([]*Any, 0)
4185 a, ok := v16.([]interface{})
4187 for _, item := range a {
4188 y, err := NewAny(item, compiler.NewContext("enum", context))
4190 errors = append(errors, err)
4192 x.Enum = append(x.Enum, y)
4196 // float multiple_of = 17;
4197 v17 := compiler.MapValueForKey(m, "multipleOf")
4199 switch v17 := v17.(type) {
4203 x.MultipleOf = float64(v17)
4205 x.MultipleOf = float64(v17)
4207 x.MultipleOf = float64(v17)
4209 x.MultipleOf = float64(v17)
4211 x.MultipleOf = float64(v17)
4213 x.MultipleOf = float64(v17)
4215 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v17, v17)
4216 errors = append(errors, compiler.NewError(context, message))
4219 // repeated NamedAny vendor_extension = 18;
4221 x.VendorExtension = make([]*NamedAny, 0)
4222 for _, item := range m {
4223 k, ok := compiler.StringValue(item.Key)
4226 if strings.HasPrefix(k, "x-") {
4230 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
4233 errors = append(errors, err)
4235 bytes, _ := yaml.Marshal(v)
4236 result.Yaml = string(bytes)
4237 result.Value = resultFromExt
4241 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
4243 errors = append(errors, err)
4246 x.VendorExtension = append(x.VendorExtension, pair)
4251 return x, compiler.NewErrorGroupOrNil(errors)
4254 // NewProperties creates an object of type Properties if possible, returning an error if not.
4255 func NewProperties(in interface{}, context *compiler.Context) (*Properties, error) {
4256 errors := make([]error, 0)
4258 m, ok := compiler.UnpackMap(in)
4260 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4261 errors = append(errors, compiler.NewError(context, message))
4263 // repeated NamedSchema additional_properties = 1;
4265 x.AdditionalProperties = make([]*NamedSchema, 0)
4266 for _, item := range m {
4267 k, ok := compiler.StringValue(item.Key)
4270 pair := &NamedSchema{}
4273 pair.Value, err = NewSchema(v, compiler.NewContext(k, context))
4275 errors = append(errors, err)
4277 x.AdditionalProperties = append(x.AdditionalProperties, pair)
4281 return x, compiler.NewErrorGroupOrNil(errors)
4284 // NewQueryParameterSubSchema creates an object of type QueryParameterSubSchema if possible, returning an error if not.
4285 func NewQueryParameterSubSchema(in interface{}, context *compiler.Context) (*QueryParameterSubSchema, error) {
4286 errors := make([]error, 0)
4287 x := &QueryParameterSubSchema{}
4288 m, ok := compiler.UnpackMap(in)
4290 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4291 errors = append(errors, compiler.NewError(context, message))
4293 allowedKeys := []string{"allowEmptyValue", "collectionFormat", "default", "description", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "in", "items", "maxItems", "maxLength", "maximum", "minItems", "minLength", "minimum", "multipleOf", "name", "pattern", "required", "type", "uniqueItems"}
4294 allowedPatterns := []*regexp.Regexp{pattern0}
4295 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
4296 if len(invalidKeys) > 0 {
4297 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
4298 errors = append(errors, compiler.NewError(context, message))
4300 // bool required = 1;
4301 v1 := compiler.MapValueForKey(m, "required")
4303 x.Required, ok = v1.(bool)
4305 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v1, v1)
4306 errors = append(errors, compiler.NewError(context, message))
4310 v2 := compiler.MapValueForKey(m, "in")
4312 x.In, ok = v2.(string)
4314 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
4315 errors = append(errors, compiler.NewError(context, message))
4317 // check for valid enum values
4319 if ok && !compiler.StringArrayContainsValue([]string{"query"}, x.In) {
4320 message := fmt.Sprintf("has unexpected value for in: %+v (%T)", v2, v2)
4321 errors = append(errors, compiler.NewError(context, message))
4324 // string description = 3;
4325 v3 := compiler.MapValueForKey(m, "description")
4327 x.Description, ok = v3.(string)
4329 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v3, v3)
4330 errors = append(errors, compiler.NewError(context, message))
4334 v4 := compiler.MapValueForKey(m, "name")
4336 x.Name, ok = v4.(string)
4338 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v4, v4)
4339 errors = append(errors, compiler.NewError(context, message))
4342 // bool allow_empty_value = 5;
4343 v5 := compiler.MapValueForKey(m, "allowEmptyValue")
4345 x.AllowEmptyValue, ok = v5.(bool)
4347 message := fmt.Sprintf("has unexpected value for allowEmptyValue: %+v (%T)", v5, v5)
4348 errors = append(errors, compiler.NewError(context, message))
4352 v6 := compiler.MapValueForKey(m, "type")
4354 x.Type, ok = v6.(string)
4356 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
4357 errors = append(errors, compiler.NewError(context, message))
4359 // check for valid enum values
4360 // [string number boolean integer array]
4361 if ok && !compiler.StringArrayContainsValue([]string{"string", "number", "boolean", "integer", "array"}, x.Type) {
4362 message := fmt.Sprintf("has unexpected value for type: %+v (%T)", v6, v6)
4363 errors = append(errors, compiler.NewError(context, message))
4366 // string format = 7;
4367 v7 := compiler.MapValueForKey(m, "format")
4369 x.Format, ok = v7.(string)
4371 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v7, v7)
4372 errors = append(errors, compiler.NewError(context, message))
4375 // PrimitivesItems items = 8;
4376 v8 := compiler.MapValueForKey(m, "items")
4379 x.Items, err = NewPrimitivesItems(v8, compiler.NewContext("items", context))
4381 errors = append(errors, err)
4384 // string collection_format = 9;
4385 v9 := compiler.MapValueForKey(m, "collectionFormat")
4387 x.CollectionFormat, ok = v9.(string)
4389 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v9, v9)
4390 errors = append(errors, compiler.NewError(context, message))
4392 // check for valid enum values
4393 // [csv ssv tsv pipes multi]
4394 if ok && !compiler.StringArrayContainsValue([]string{"csv", "ssv", "tsv", "pipes", "multi"}, x.CollectionFormat) {
4395 message := fmt.Sprintf("has unexpected value for collectionFormat: %+v (%T)", v9, v9)
4396 errors = append(errors, compiler.NewError(context, message))
4399 // Any default = 10;
4400 v10 := compiler.MapValueForKey(m, "default")
4403 x.Default, err = NewAny(v10, compiler.NewContext("default", context))
4405 errors = append(errors, err)
4408 // float maximum = 11;
4409 v11 := compiler.MapValueForKey(m, "maximum")
4411 switch v11 := v11.(type) {
4415 x.Maximum = float64(v11)
4417 x.Maximum = float64(v11)
4419 x.Maximum = float64(v11)
4421 x.Maximum = float64(v11)
4423 x.Maximum = float64(v11)
4425 x.Maximum = float64(v11)
4427 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v11, v11)
4428 errors = append(errors, compiler.NewError(context, message))
4431 // bool exclusive_maximum = 12;
4432 v12 := compiler.MapValueForKey(m, "exclusiveMaximum")
4434 x.ExclusiveMaximum, ok = v12.(bool)
4436 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v12, v12)
4437 errors = append(errors, compiler.NewError(context, message))
4440 // float minimum = 13;
4441 v13 := compiler.MapValueForKey(m, "minimum")
4443 switch v13 := v13.(type) {
4447 x.Minimum = float64(v13)
4449 x.Minimum = float64(v13)
4451 x.Minimum = float64(v13)
4453 x.Minimum = float64(v13)
4455 x.Minimum = float64(v13)
4457 x.Minimum = float64(v13)
4459 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v13, v13)
4460 errors = append(errors, compiler.NewError(context, message))
4463 // bool exclusive_minimum = 14;
4464 v14 := compiler.MapValueForKey(m, "exclusiveMinimum")
4466 x.ExclusiveMinimum, ok = v14.(bool)
4468 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v14, v14)
4469 errors = append(errors, compiler.NewError(context, message))
4472 // int64 max_length = 15;
4473 v15 := compiler.MapValueForKey(m, "maxLength")
4477 x.MaxLength = int64(t)
4479 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v15, v15)
4480 errors = append(errors, compiler.NewError(context, message))
4483 // int64 min_length = 16;
4484 v16 := compiler.MapValueForKey(m, "minLength")
4488 x.MinLength = int64(t)
4490 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v16, v16)
4491 errors = append(errors, compiler.NewError(context, message))
4494 // string pattern = 17;
4495 v17 := compiler.MapValueForKey(m, "pattern")
4497 x.Pattern, ok = v17.(string)
4499 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v17, v17)
4500 errors = append(errors, compiler.NewError(context, message))
4503 // int64 max_items = 18;
4504 v18 := compiler.MapValueForKey(m, "maxItems")
4508 x.MaxItems = int64(t)
4510 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v18, v18)
4511 errors = append(errors, compiler.NewError(context, message))
4514 // int64 min_items = 19;
4515 v19 := compiler.MapValueForKey(m, "minItems")
4519 x.MinItems = int64(t)
4521 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v19, v19)
4522 errors = append(errors, compiler.NewError(context, message))
4525 // bool unique_items = 20;
4526 v20 := compiler.MapValueForKey(m, "uniqueItems")
4528 x.UniqueItems, ok = v20.(bool)
4530 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v20, v20)
4531 errors = append(errors, compiler.NewError(context, message))
4534 // repeated Any enum = 21;
4535 v21 := compiler.MapValueForKey(m, "enum")
4538 x.Enum = make([]*Any, 0)
4539 a, ok := v21.([]interface{})
4541 for _, item := range a {
4542 y, err := NewAny(item, compiler.NewContext("enum", context))
4544 errors = append(errors, err)
4546 x.Enum = append(x.Enum, y)
4550 // float multiple_of = 22;
4551 v22 := compiler.MapValueForKey(m, "multipleOf")
4553 switch v22 := v22.(type) {
4557 x.MultipleOf = float64(v22)
4559 x.MultipleOf = float64(v22)
4561 x.MultipleOf = float64(v22)
4563 x.MultipleOf = float64(v22)
4565 x.MultipleOf = float64(v22)
4567 x.MultipleOf = float64(v22)
4569 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v22, v22)
4570 errors = append(errors, compiler.NewError(context, message))
4573 // repeated NamedAny vendor_extension = 23;
4575 x.VendorExtension = make([]*NamedAny, 0)
4576 for _, item := range m {
4577 k, ok := compiler.StringValue(item.Key)
4580 if strings.HasPrefix(k, "x-") {
4584 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
4587 errors = append(errors, err)
4589 bytes, _ := yaml.Marshal(v)
4590 result.Yaml = string(bytes)
4591 result.Value = resultFromExt
4595 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
4597 errors = append(errors, err)
4600 x.VendorExtension = append(x.VendorExtension, pair)
4605 return x, compiler.NewErrorGroupOrNil(errors)
4608 // NewResponse creates an object of type Response if possible, returning an error if not.
4609 func NewResponse(in interface{}, context *compiler.Context) (*Response, error) {
4610 errors := make([]error, 0)
4612 m, ok := compiler.UnpackMap(in)
4614 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4615 errors = append(errors, compiler.NewError(context, message))
4617 requiredKeys := []string{"description"}
4618 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
4619 if len(missingKeys) > 0 {
4620 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
4621 errors = append(errors, compiler.NewError(context, message))
4623 allowedKeys := []string{"description", "examples", "headers", "schema"}
4624 allowedPatterns := []*regexp.Regexp{pattern0}
4625 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
4626 if len(invalidKeys) > 0 {
4627 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
4628 errors = append(errors, compiler.NewError(context, message))
4630 // string description = 1;
4631 v1 := compiler.MapValueForKey(m, "description")
4633 x.Description, ok = v1.(string)
4635 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v1, v1)
4636 errors = append(errors, compiler.NewError(context, message))
4639 // SchemaItem schema = 2;
4640 v2 := compiler.MapValueForKey(m, "schema")
4643 x.Schema, err = NewSchemaItem(v2, compiler.NewContext("schema", context))
4645 errors = append(errors, err)
4648 // Headers headers = 3;
4649 v3 := compiler.MapValueForKey(m, "headers")
4652 x.Headers, err = NewHeaders(v3, compiler.NewContext("headers", context))
4654 errors = append(errors, err)
4657 // Examples examples = 4;
4658 v4 := compiler.MapValueForKey(m, "examples")
4661 x.Examples, err = NewExamples(v4, compiler.NewContext("examples", context))
4663 errors = append(errors, err)
4666 // repeated NamedAny vendor_extension = 5;
4668 x.VendorExtension = make([]*NamedAny, 0)
4669 for _, item := range m {
4670 k, ok := compiler.StringValue(item.Key)
4673 if strings.HasPrefix(k, "x-") {
4677 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
4680 errors = append(errors, err)
4682 bytes, _ := yaml.Marshal(v)
4683 result.Yaml = string(bytes)
4684 result.Value = resultFromExt
4688 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
4690 errors = append(errors, err)
4693 x.VendorExtension = append(x.VendorExtension, pair)
4698 return x, compiler.NewErrorGroupOrNil(errors)
4701 // NewResponseDefinitions creates an object of type ResponseDefinitions if possible, returning an error if not.
4702 func NewResponseDefinitions(in interface{}, context *compiler.Context) (*ResponseDefinitions, error) {
4703 errors := make([]error, 0)
4704 x := &ResponseDefinitions{}
4705 m, ok := compiler.UnpackMap(in)
4707 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4708 errors = append(errors, compiler.NewError(context, message))
4710 // repeated NamedResponse additional_properties = 1;
4712 x.AdditionalProperties = make([]*NamedResponse, 0)
4713 for _, item := range m {
4714 k, ok := compiler.StringValue(item.Key)
4717 pair := &NamedResponse{}
4720 pair.Value, err = NewResponse(v, compiler.NewContext(k, context))
4722 errors = append(errors, err)
4724 x.AdditionalProperties = append(x.AdditionalProperties, pair)
4728 return x, compiler.NewErrorGroupOrNil(errors)
4731 // NewResponseValue creates an object of type ResponseValue if possible, returning an error if not.
4732 func NewResponseValue(in interface{}, context *compiler.Context) (*ResponseValue, error) {
4733 errors := make([]error, 0)
4734 x := &ResponseValue{}
4736 // Response response = 1;
4738 m, ok := compiler.UnpackMap(in)
4740 // errors might be ok here, they mean we just don't have the right subtype
4741 t, matchingError := NewResponse(m, compiler.NewContext("response", context))
4742 if matchingError == nil {
4743 x.Oneof = &ResponseValue_Response{Response: t}
4746 errors = append(errors, matchingError)
4750 // JsonReference json_reference = 2;
4752 m, ok := compiler.UnpackMap(in)
4754 // errors might be ok here, they mean we just don't have the right subtype
4755 t, matchingError := NewJsonReference(m, compiler.NewContext("jsonReference", context))
4756 if matchingError == nil {
4757 x.Oneof = &ResponseValue_JsonReference{JsonReference: t}
4760 errors = append(errors, matchingError)
4765 // since the oneof matched one of its possibilities, discard any matching errors
4766 errors = make([]error, 0)
4768 return x, compiler.NewErrorGroupOrNil(errors)
4771 // NewResponses creates an object of type Responses if possible, returning an error if not.
4772 func NewResponses(in interface{}, context *compiler.Context) (*Responses, error) {
4773 errors := make([]error, 0)
4775 m, ok := compiler.UnpackMap(in)
4777 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4778 errors = append(errors, compiler.NewError(context, message))
4780 allowedKeys := []string{}
4781 allowedPatterns := []*regexp.Regexp{pattern2, pattern0}
4782 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
4783 if len(invalidKeys) > 0 {
4784 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
4785 errors = append(errors, compiler.NewError(context, message))
4787 // repeated NamedResponseValue response_code = 1;
4788 // MAP: ResponseValue ^([0-9]{3})$|^(default)$
4789 x.ResponseCode = make([]*NamedResponseValue, 0)
4790 for _, item := range m {
4791 k, ok := compiler.StringValue(item.Key)
4794 if pattern2.MatchString(k) {
4795 pair := &NamedResponseValue{}
4798 pair.Value, err = NewResponseValue(v, compiler.NewContext(k, context))
4800 errors = append(errors, err)
4802 x.ResponseCode = append(x.ResponseCode, pair)
4806 // repeated NamedAny vendor_extension = 2;
4808 x.VendorExtension = make([]*NamedAny, 0)
4809 for _, item := range m {
4810 k, ok := compiler.StringValue(item.Key)
4813 if strings.HasPrefix(k, "x-") {
4817 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
4820 errors = append(errors, err)
4822 bytes, _ := yaml.Marshal(v)
4823 result.Yaml = string(bytes)
4824 result.Value = resultFromExt
4828 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
4830 errors = append(errors, err)
4833 x.VendorExtension = append(x.VendorExtension, pair)
4838 return x, compiler.NewErrorGroupOrNil(errors)
4841 // NewSchema creates an object of type Schema if possible, returning an error if not.
4842 func NewSchema(in interface{}, context *compiler.Context) (*Schema, error) {
4843 errors := make([]error, 0)
4845 m, ok := compiler.UnpackMap(in)
4847 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
4848 errors = append(errors, compiler.NewError(context, message))
4850 allowedKeys := []string{"$ref", "additionalProperties", "allOf", "default", "description", "discriminator", "enum", "example", "exclusiveMaximum", "exclusiveMinimum", "externalDocs", "format", "items", "maxItems", "maxLength", "maxProperties", "maximum", "minItems", "minLength", "minProperties", "minimum", "multipleOf", "pattern", "properties", "readOnly", "required", "title", "type", "uniqueItems", "xml"}
4851 allowedPatterns := []*regexp.Regexp{pattern0}
4852 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
4853 if len(invalidKeys) > 0 {
4854 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
4855 errors = append(errors, compiler.NewError(context, message))
4858 v1 := compiler.MapValueForKey(m, "$ref")
4860 x.XRef, ok = v1.(string)
4862 message := fmt.Sprintf("has unexpected value for $ref: %+v (%T)", v1, v1)
4863 errors = append(errors, compiler.NewError(context, message))
4866 // string format = 2;
4867 v2 := compiler.MapValueForKey(m, "format")
4869 x.Format, ok = v2.(string)
4871 message := fmt.Sprintf("has unexpected value for format: %+v (%T)", v2, v2)
4872 errors = append(errors, compiler.NewError(context, message))
4875 // string title = 3;
4876 v3 := compiler.MapValueForKey(m, "title")
4878 x.Title, ok = v3.(string)
4880 message := fmt.Sprintf("has unexpected value for title: %+v (%T)", v3, v3)
4881 errors = append(errors, compiler.NewError(context, message))
4884 // string description = 4;
4885 v4 := compiler.MapValueForKey(m, "description")
4887 x.Description, ok = v4.(string)
4889 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v4, v4)
4890 errors = append(errors, compiler.NewError(context, message))
4894 v5 := compiler.MapValueForKey(m, "default")
4897 x.Default, err = NewAny(v5, compiler.NewContext("default", context))
4899 errors = append(errors, err)
4902 // float multiple_of = 6;
4903 v6 := compiler.MapValueForKey(m, "multipleOf")
4905 switch v6 := v6.(type) {
4909 x.MultipleOf = float64(v6)
4911 x.MultipleOf = float64(v6)
4913 x.MultipleOf = float64(v6)
4915 x.MultipleOf = float64(v6)
4917 x.MultipleOf = float64(v6)
4919 x.MultipleOf = float64(v6)
4921 message := fmt.Sprintf("has unexpected value for multipleOf: %+v (%T)", v6, v6)
4922 errors = append(errors, compiler.NewError(context, message))
4925 // float maximum = 7;
4926 v7 := compiler.MapValueForKey(m, "maximum")
4928 switch v7 := v7.(type) {
4932 x.Maximum = float64(v7)
4934 x.Maximum = float64(v7)
4936 x.Maximum = float64(v7)
4938 x.Maximum = float64(v7)
4940 x.Maximum = float64(v7)
4942 x.Maximum = float64(v7)
4944 message := fmt.Sprintf("has unexpected value for maximum: %+v (%T)", v7, v7)
4945 errors = append(errors, compiler.NewError(context, message))
4948 // bool exclusive_maximum = 8;
4949 v8 := compiler.MapValueForKey(m, "exclusiveMaximum")
4951 x.ExclusiveMaximum, ok = v8.(bool)
4953 message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %+v (%T)", v8, v8)
4954 errors = append(errors, compiler.NewError(context, message))
4957 // float minimum = 9;
4958 v9 := compiler.MapValueForKey(m, "minimum")
4960 switch v9 := v9.(type) {
4964 x.Minimum = float64(v9)
4966 x.Minimum = float64(v9)
4968 x.Minimum = float64(v9)
4970 x.Minimum = float64(v9)
4972 x.Minimum = float64(v9)
4974 x.Minimum = float64(v9)
4976 message := fmt.Sprintf("has unexpected value for minimum: %+v (%T)", v9, v9)
4977 errors = append(errors, compiler.NewError(context, message))
4980 // bool exclusive_minimum = 10;
4981 v10 := compiler.MapValueForKey(m, "exclusiveMinimum")
4983 x.ExclusiveMinimum, ok = v10.(bool)
4985 message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %+v (%T)", v10, v10)
4986 errors = append(errors, compiler.NewError(context, message))
4989 // int64 max_length = 11;
4990 v11 := compiler.MapValueForKey(m, "maxLength")
4994 x.MaxLength = int64(t)
4996 message := fmt.Sprintf("has unexpected value for maxLength: %+v (%T)", v11, v11)
4997 errors = append(errors, compiler.NewError(context, message))
5000 // int64 min_length = 12;
5001 v12 := compiler.MapValueForKey(m, "minLength")
5005 x.MinLength = int64(t)
5007 message := fmt.Sprintf("has unexpected value for minLength: %+v (%T)", v12, v12)
5008 errors = append(errors, compiler.NewError(context, message))
5011 // string pattern = 13;
5012 v13 := compiler.MapValueForKey(m, "pattern")
5014 x.Pattern, ok = v13.(string)
5016 message := fmt.Sprintf("has unexpected value for pattern: %+v (%T)", v13, v13)
5017 errors = append(errors, compiler.NewError(context, message))
5020 // int64 max_items = 14;
5021 v14 := compiler.MapValueForKey(m, "maxItems")
5025 x.MaxItems = int64(t)
5027 message := fmt.Sprintf("has unexpected value for maxItems: %+v (%T)", v14, v14)
5028 errors = append(errors, compiler.NewError(context, message))
5031 // int64 min_items = 15;
5032 v15 := compiler.MapValueForKey(m, "minItems")
5036 x.MinItems = int64(t)
5038 message := fmt.Sprintf("has unexpected value for minItems: %+v (%T)", v15, v15)
5039 errors = append(errors, compiler.NewError(context, message))
5042 // bool unique_items = 16;
5043 v16 := compiler.MapValueForKey(m, "uniqueItems")
5045 x.UniqueItems, ok = v16.(bool)
5047 message := fmt.Sprintf("has unexpected value for uniqueItems: %+v (%T)", v16, v16)
5048 errors = append(errors, compiler.NewError(context, message))
5051 // int64 max_properties = 17;
5052 v17 := compiler.MapValueForKey(m, "maxProperties")
5056 x.MaxProperties = int64(t)
5058 message := fmt.Sprintf("has unexpected value for maxProperties: %+v (%T)", v17, v17)
5059 errors = append(errors, compiler.NewError(context, message))
5062 // int64 min_properties = 18;
5063 v18 := compiler.MapValueForKey(m, "minProperties")
5067 x.MinProperties = int64(t)
5069 message := fmt.Sprintf("has unexpected value for minProperties: %+v (%T)", v18, v18)
5070 errors = append(errors, compiler.NewError(context, message))
5073 // repeated string required = 19;
5074 v19 := compiler.MapValueForKey(m, "required")
5076 v, ok := v19.([]interface{})
5078 x.Required = compiler.ConvertInterfaceArrayToStringArray(v)
5080 message := fmt.Sprintf("has unexpected value for required: %+v (%T)", v19, v19)
5081 errors = append(errors, compiler.NewError(context, message))
5084 // repeated Any enum = 20;
5085 v20 := compiler.MapValueForKey(m, "enum")
5088 x.Enum = make([]*Any, 0)
5089 a, ok := v20.([]interface{})
5091 for _, item := range a {
5092 y, err := NewAny(item, compiler.NewContext("enum", context))
5094 errors = append(errors, err)
5096 x.Enum = append(x.Enum, y)
5100 // AdditionalPropertiesItem additional_properties = 21;
5101 v21 := compiler.MapValueForKey(m, "additionalProperties")
5104 x.AdditionalProperties, err = NewAdditionalPropertiesItem(v21, compiler.NewContext("additionalProperties", context))
5106 errors = append(errors, err)
5109 // TypeItem type = 22;
5110 v22 := compiler.MapValueForKey(m, "type")
5113 x.Type, err = NewTypeItem(v22, compiler.NewContext("type", context))
5115 errors = append(errors, err)
5118 // ItemsItem items = 23;
5119 v23 := compiler.MapValueForKey(m, "items")
5122 x.Items, err = NewItemsItem(v23, compiler.NewContext("items", context))
5124 errors = append(errors, err)
5127 // repeated Schema all_of = 24;
5128 v24 := compiler.MapValueForKey(m, "allOf")
5131 x.AllOf = make([]*Schema, 0)
5132 a, ok := v24.([]interface{})
5134 for _, item := range a {
5135 y, err := NewSchema(item, compiler.NewContext("allOf", context))
5137 errors = append(errors, err)
5139 x.AllOf = append(x.AllOf, y)
5143 // Properties properties = 25;
5144 v25 := compiler.MapValueForKey(m, "properties")
5147 x.Properties, err = NewProperties(v25, compiler.NewContext("properties", context))
5149 errors = append(errors, err)
5152 // string discriminator = 26;
5153 v26 := compiler.MapValueForKey(m, "discriminator")
5155 x.Discriminator, ok = v26.(string)
5157 message := fmt.Sprintf("has unexpected value for discriminator: %+v (%T)", v26, v26)
5158 errors = append(errors, compiler.NewError(context, message))
5161 // bool read_only = 27;
5162 v27 := compiler.MapValueForKey(m, "readOnly")
5164 x.ReadOnly, ok = v27.(bool)
5166 message := fmt.Sprintf("has unexpected value for readOnly: %+v (%T)", v27, v27)
5167 errors = append(errors, compiler.NewError(context, message))
5171 v28 := compiler.MapValueForKey(m, "xml")
5174 x.Xml, err = NewXml(v28, compiler.NewContext("xml", context))
5176 errors = append(errors, err)
5179 // ExternalDocs external_docs = 29;
5180 v29 := compiler.MapValueForKey(m, "externalDocs")
5183 x.ExternalDocs, err = NewExternalDocs(v29, compiler.NewContext("externalDocs", context))
5185 errors = append(errors, err)
5188 // Any example = 30;
5189 v30 := compiler.MapValueForKey(m, "example")
5192 x.Example, err = NewAny(v30, compiler.NewContext("example", context))
5194 errors = append(errors, err)
5197 // repeated NamedAny vendor_extension = 31;
5199 x.VendorExtension = make([]*NamedAny, 0)
5200 for _, item := range m {
5201 k, ok := compiler.StringValue(item.Key)
5204 if strings.HasPrefix(k, "x-") {
5208 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
5211 errors = append(errors, err)
5213 bytes, _ := yaml.Marshal(v)
5214 result.Yaml = string(bytes)
5215 result.Value = resultFromExt
5219 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
5221 errors = append(errors, err)
5224 x.VendorExtension = append(x.VendorExtension, pair)
5229 return x, compiler.NewErrorGroupOrNil(errors)
5232 // NewSchemaItem creates an object of type SchemaItem if possible, returning an error if not.
5233 func NewSchemaItem(in interface{}, context *compiler.Context) (*SchemaItem, error) {
5234 errors := make([]error, 0)
5237 // Schema schema = 1;
5239 m, ok := compiler.UnpackMap(in)
5241 // errors might be ok here, they mean we just don't have the right subtype
5242 t, matchingError := NewSchema(m, compiler.NewContext("schema", context))
5243 if matchingError == nil {
5244 x.Oneof = &SchemaItem_Schema{Schema: t}
5247 errors = append(errors, matchingError)
5251 // FileSchema file_schema = 2;
5253 m, ok := compiler.UnpackMap(in)
5255 // errors might be ok here, they mean we just don't have the right subtype
5256 t, matchingError := NewFileSchema(m, compiler.NewContext("fileSchema", context))
5257 if matchingError == nil {
5258 x.Oneof = &SchemaItem_FileSchema{FileSchema: t}
5261 errors = append(errors, matchingError)
5266 // since the oneof matched one of its possibilities, discard any matching errors
5267 errors = make([]error, 0)
5269 return x, compiler.NewErrorGroupOrNil(errors)
5272 // NewSecurityDefinitions creates an object of type SecurityDefinitions if possible, returning an error if not.
5273 func NewSecurityDefinitions(in interface{}, context *compiler.Context) (*SecurityDefinitions, error) {
5274 errors := make([]error, 0)
5275 x := &SecurityDefinitions{}
5276 m, ok := compiler.UnpackMap(in)
5278 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
5279 errors = append(errors, compiler.NewError(context, message))
5281 // repeated NamedSecurityDefinitionsItem additional_properties = 1;
5282 // MAP: SecurityDefinitionsItem
5283 x.AdditionalProperties = make([]*NamedSecurityDefinitionsItem, 0)
5284 for _, item := range m {
5285 k, ok := compiler.StringValue(item.Key)
5288 pair := &NamedSecurityDefinitionsItem{}
5291 pair.Value, err = NewSecurityDefinitionsItem(v, compiler.NewContext(k, context))
5293 errors = append(errors, err)
5295 x.AdditionalProperties = append(x.AdditionalProperties, pair)
5299 return x, compiler.NewErrorGroupOrNil(errors)
5302 // NewSecurityDefinitionsItem creates an object of type SecurityDefinitionsItem if possible, returning an error if not.
5303 func NewSecurityDefinitionsItem(in interface{}, context *compiler.Context) (*SecurityDefinitionsItem, error) {
5304 errors := make([]error, 0)
5305 x := &SecurityDefinitionsItem{}
5307 // BasicAuthenticationSecurity basic_authentication_security = 1;
5309 m, ok := compiler.UnpackMap(in)
5311 // errors might be ok here, they mean we just don't have the right subtype
5312 t, matchingError := NewBasicAuthenticationSecurity(m, compiler.NewContext("basicAuthenticationSecurity", context))
5313 if matchingError == nil {
5314 x.Oneof = &SecurityDefinitionsItem_BasicAuthenticationSecurity{BasicAuthenticationSecurity: t}
5317 errors = append(errors, matchingError)
5321 // ApiKeySecurity api_key_security = 2;
5323 m, ok := compiler.UnpackMap(in)
5325 // errors might be ok here, they mean we just don't have the right subtype
5326 t, matchingError := NewApiKeySecurity(m, compiler.NewContext("apiKeySecurity", context))
5327 if matchingError == nil {
5328 x.Oneof = &SecurityDefinitionsItem_ApiKeySecurity{ApiKeySecurity: t}
5331 errors = append(errors, matchingError)
5335 // Oauth2ImplicitSecurity oauth2_implicit_security = 3;
5337 m, ok := compiler.UnpackMap(in)
5339 // errors might be ok here, they mean we just don't have the right subtype
5340 t, matchingError := NewOauth2ImplicitSecurity(m, compiler.NewContext("oauth2ImplicitSecurity", context))
5341 if matchingError == nil {
5342 x.Oneof = &SecurityDefinitionsItem_Oauth2ImplicitSecurity{Oauth2ImplicitSecurity: t}
5345 errors = append(errors, matchingError)
5349 // Oauth2PasswordSecurity oauth2_password_security = 4;
5351 m, ok := compiler.UnpackMap(in)
5353 // errors might be ok here, they mean we just don't have the right subtype
5354 t, matchingError := NewOauth2PasswordSecurity(m, compiler.NewContext("oauth2PasswordSecurity", context))
5355 if matchingError == nil {
5356 x.Oneof = &SecurityDefinitionsItem_Oauth2PasswordSecurity{Oauth2PasswordSecurity: t}
5359 errors = append(errors, matchingError)
5363 // Oauth2ApplicationSecurity oauth2_application_security = 5;
5365 m, ok := compiler.UnpackMap(in)
5367 // errors might be ok here, they mean we just don't have the right subtype
5368 t, matchingError := NewOauth2ApplicationSecurity(m, compiler.NewContext("oauth2ApplicationSecurity", context))
5369 if matchingError == nil {
5370 x.Oneof = &SecurityDefinitionsItem_Oauth2ApplicationSecurity{Oauth2ApplicationSecurity: t}
5373 errors = append(errors, matchingError)
5377 // Oauth2AccessCodeSecurity oauth2_access_code_security = 6;
5379 m, ok := compiler.UnpackMap(in)
5381 // errors might be ok here, they mean we just don't have the right subtype
5382 t, matchingError := NewOauth2AccessCodeSecurity(m, compiler.NewContext("oauth2AccessCodeSecurity", context))
5383 if matchingError == nil {
5384 x.Oneof = &SecurityDefinitionsItem_Oauth2AccessCodeSecurity{Oauth2AccessCodeSecurity: t}
5387 errors = append(errors, matchingError)
5392 // since the oneof matched one of its possibilities, discard any matching errors
5393 errors = make([]error, 0)
5395 return x, compiler.NewErrorGroupOrNil(errors)
5398 // NewSecurityRequirement creates an object of type SecurityRequirement if possible, returning an error if not.
5399 func NewSecurityRequirement(in interface{}, context *compiler.Context) (*SecurityRequirement, error) {
5400 errors := make([]error, 0)
5401 x := &SecurityRequirement{}
5402 m, ok := compiler.UnpackMap(in)
5404 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
5405 errors = append(errors, compiler.NewError(context, message))
5407 // repeated NamedStringArray additional_properties = 1;
5409 x.AdditionalProperties = make([]*NamedStringArray, 0)
5410 for _, item := range m {
5411 k, ok := compiler.StringValue(item.Key)
5414 pair := &NamedStringArray{}
5417 pair.Value, err = NewStringArray(v, compiler.NewContext(k, context))
5419 errors = append(errors, err)
5421 x.AdditionalProperties = append(x.AdditionalProperties, pair)
5425 return x, compiler.NewErrorGroupOrNil(errors)
5428 // NewStringArray creates an object of type StringArray if possible, returning an error if not.
5429 func NewStringArray(in interface{}, context *compiler.Context) (*StringArray, error) {
5430 errors := make([]error, 0)
5432 a, ok := in.([]interface{})
5434 message := fmt.Sprintf("has unexpected value for StringArray: %+v (%T)", in, in)
5435 errors = append(errors, compiler.NewError(context, message))
5437 x.Value = make([]string, 0)
5438 for _, s := range a {
5439 x.Value = append(x.Value, s.(string))
5442 return x, compiler.NewErrorGroupOrNil(errors)
5445 // NewTag creates an object of type Tag if possible, returning an error if not.
5446 func NewTag(in interface{}, context *compiler.Context) (*Tag, error) {
5447 errors := make([]error, 0)
5449 m, ok := compiler.UnpackMap(in)
5451 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
5452 errors = append(errors, compiler.NewError(context, message))
5454 requiredKeys := []string{"name"}
5455 missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
5456 if len(missingKeys) > 0 {
5457 message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
5458 errors = append(errors, compiler.NewError(context, message))
5460 allowedKeys := []string{"description", "externalDocs", "name"}
5461 allowedPatterns := []*regexp.Regexp{pattern0}
5462 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
5463 if len(invalidKeys) > 0 {
5464 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
5465 errors = append(errors, compiler.NewError(context, message))
5468 v1 := compiler.MapValueForKey(m, "name")
5470 x.Name, ok = v1.(string)
5472 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
5473 errors = append(errors, compiler.NewError(context, message))
5476 // string description = 2;
5477 v2 := compiler.MapValueForKey(m, "description")
5479 x.Description, ok = v2.(string)
5481 message := fmt.Sprintf("has unexpected value for description: %+v (%T)", v2, v2)
5482 errors = append(errors, compiler.NewError(context, message))
5485 // ExternalDocs external_docs = 3;
5486 v3 := compiler.MapValueForKey(m, "externalDocs")
5489 x.ExternalDocs, err = NewExternalDocs(v3, compiler.NewContext("externalDocs", context))
5491 errors = append(errors, err)
5494 // repeated NamedAny vendor_extension = 4;
5496 x.VendorExtension = make([]*NamedAny, 0)
5497 for _, item := range m {
5498 k, ok := compiler.StringValue(item.Key)
5501 if strings.HasPrefix(k, "x-") {
5505 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
5508 errors = append(errors, err)
5510 bytes, _ := yaml.Marshal(v)
5511 result.Yaml = string(bytes)
5512 result.Value = resultFromExt
5516 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
5518 errors = append(errors, err)
5521 x.VendorExtension = append(x.VendorExtension, pair)
5526 return x, compiler.NewErrorGroupOrNil(errors)
5529 // NewTypeItem creates an object of type TypeItem if possible, returning an error if not.
5530 func NewTypeItem(in interface{}, context *compiler.Context) (*TypeItem, error) {
5531 errors := make([]error, 0)
5533 switch in := in.(type) {
5535 x.Value = make([]string, 0)
5536 x.Value = append(x.Value, in)
5538 x.Value = make([]string, 0)
5539 for _, v := range in {
5540 value, ok := v.(string)
5542 x.Value = append(x.Value, value)
5544 message := fmt.Sprintf("has unexpected value for string array element: %+v (%T)", value, value)
5545 errors = append(errors, compiler.NewError(context, message))
5549 message := fmt.Sprintf("has unexpected value for string array: %+v (%T)", in, in)
5550 errors = append(errors, compiler.NewError(context, message))
5552 return x, compiler.NewErrorGroupOrNil(errors)
5555 // NewVendorExtension creates an object of type VendorExtension if possible, returning an error if not.
5556 func NewVendorExtension(in interface{}, context *compiler.Context) (*VendorExtension, error) {
5557 errors := make([]error, 0)
5558 x := &VendorExtension{}
5559 m, ok := compiler.UnpackMap(in)
5561 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
5562 errors = append(errors, compiler.NewError(context, message))
5564 // repeated NamedAny additional_properties = 1;
5566 x.AdditionalProperties = make([]*NamedAny, 0)
5567 for _, item := range m {
5568 k, ok := compiler.StringValue(item.Key)
5574 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
5577 errors = append(errors, err)
5579 bytes, _ := yaml.Marshal(v)
5580 result.Yaml = string(bytes)
5581 result.Value = resultFromExt
5585 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
5587 errors = append(errors, err)
5590 x.AdditionalProperties = append(x.AdditionalProperties, pair)
5594 return x, compiler.NewErrorGroupOrNil(errors)
5597 // NewXml creates an object of type Xml if possible, returning an error if not.
5598 func NewXml(in interface{}, context *compiler.Context) (*Xml, error) {
5599 errors := make([]error, 0)
5601 m, ok := compiler.UnpackMap(in)
5603 message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
5604 errors = append(errors, compiler.NewError(context, message))
5606 allowedKeys := []string{"attribute", "name", "namespace", "prefix", "wrapped"}
5607 allowedPatterns := []*regexp.Regexp{pattern0}
5608 invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
5609 if len(invalidKeys) > 0 {
5610 message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
5611 errors = append(errors, compiler.NewError(context, message))
5614 v1 := compiler.MapValueForKey(m, "name")
5616 x.Name, ok = v1.(string)
5618 message := fmt.Sprintf("has unexpected value for name: %+v (%T)", v1, v1)
5619 errors = append(errors, compiler.NewError(context, message))
5622 // string namespace = 2;
5623 v2 := compiler.MapValueForKey(m, "namespace")
5625 x.Namespace, ok = v2.(string)
5627 message := fmt.Sprintf("has unexpected value for namespace: %+v (%T)", v2, v2)
5628 errors = append(errors, compiler.NewError(context, message))
5631 // string prefix = 3;
5632 v3 := compiler.MapValueForKey(m, "prefix")
5634 x.Prefix, ok = v3.(string)
5636 message := fmt.Sprintf("has unexpected value for prefix: %+v (%T)", v3, v3)
5637 errors = append(errors, compiler.NewError(context, message))
5640 // bool attribute = 4;
5641 v4 := compiler.MapValueForKey(m, "attribute")
5643 x.Attribute, ok = v4.(bool)
5645 message := fmt.Sprintf("has unexpected value for attribute: %+v (%T)", v4, v4)
5646 errors = append(errors, compiler.NewError(context, message))
5649 // bool wrapped = 5;
5650 v5 := compiler.MapValueForKey(m, "wrapped")
5652 x.Wrapped, ok = v5.(bool)
5654 message := fmt.Sprintf("has unexpected value for wrapped: %+v (%T)", v5, v5)
5655 errors = append(errors, compiler.NewError(context, message))
5658 // repeated NamedAny vendor_extension = 6;
5660 x.VendorExtension = make([]*NamedAny, 0)
5661 for _, item := range m {
5662 k, ok := compiler.StringValue(item.Key)
5665 if strings.HasPrefix(k, "x-") {
5669 handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
5672 errors = append(errors, err)
5674 bytes, _ := yaml.Marshal(v)
5675 result.Yaml = string(bytes)
5676 result.Value = resultFromExt
5680 pair.Value, err = NewAny(v, compiler.NewContext(k, context))
5682 errors = append(errors, err)
5685 x.VendorExtension = append(x.VendorExtension, pair)
5690 return x, compiler.NewErrorGroupOrNil(errors)
5693 // ResolveReferences resolves references found inside AdditionalPropertiesItem objects.
5694 func (m *AdditionalPropertiesItem) ResolveReferences(root string) (interface{}, error) {
5695 errors := make([]error, 0)
5697 p, ok := m.Oneof.(*AdditionalPropertiesItem_Schema)
5699 _, err := p.Schema.ResolveReferences(root)
5705 return nil, compiler.NewErrorGroupOrNil(errors)
5708 // ResolveReferences resolves references found inside Any objects.
5709 func (m *Any) ResolveReferences(root string) (interface{}, error) {
5710 errors := make([]error, 0)
5711 return nil, compiler.NewErrorGroupOrNil(errors)
5714 // ResolveReferences resolves references found inside ApiKeySecurity objects.
5715 func (m *ApiKeySecurity) ResolveReferences(root string) (interface{}, error) {
5716 errors := make([]error, 0)
5717 for _, item := range m.VendorExtension {
5719 _, err := item.ResolveReferences(root)
5721 errors = append(errors, err)
5725 return nil, compiler.NewErrorGroupOrNil(errors)
5728 // ResolveReferences resolves references found inside BasicAuthenticationSecurity objects.
5729 func (m *BasicAuthenticationSecurity) ResolveReferences(root string) (interface{}, error) {
5730 errors := make([]error, 0)
5731 for _, item := range m.VendorExtension {
5733 _, err := item.ResolveReferences(root)
5735 errors = append(errors, err)
5739 return nil, compiler.NewErrorGroupOrNil(errors)
5742 // ResolveReferences resolves references found inside BodyParameter objects.
5743 func (m *BodyParameter) ResolveReferences(root string) (interface{}, error) {
5744 errors := make([]error, 0)
5745 if m.Schema != nil {
5746 _, err := m.Schema.ResolveReferences(root)
5748 errors = append(errors, err)
5751 for _, item := range m.VendorExtension {
5753 _, err := item.ResolveReferences(root)
5755 errors = append(errors, err)
5759 return nil, compiler.NewErrorGroupOrNil(errors)
5762 // ResolveReferences resolves references found inside Contact objects.
5763 func (m *Contact) ResolveReferences(root string) (interface{}, error) {
5764 errors := make([]error, 0)
5765 for _, item := range m.VendorExtension {
5767 _, err := item.ResolveReferences(root)
5769 errors = append(errors, err)
5773 return nil, compiler.NewErrorGroupOrNil(errors)
5776 // ResolveReferences resolves references found inside Default objects.
5777 func (m *Default) ResolveReferences(root string) (interface{}, error) {
5778 errors := make([]error, 0)
5779 for _, item := range m.AdditionalProperties {
5781 _, err := item.ResolveReferences(root)
5783 errors = append(errors, err)
5787 return nil, compiler.NewErrorGroupOrNil(errors)
5790 // ResolveReferences resolves references found inside Definitions objects.
5791 func (m *Definitions) ResolveReferences(root string) (interface{}, error) {
5792 errors := make([]error, 0)
5793 for _, item := range m.AdditionalProperties {
5795 _, err := item.ResolveReferences(root)
5797 errors = append(errors, err)
5801 return nil, compiler.NewErrorGroupOrNil(errors)
5804 // ResolveReferences resolves references found inside Document objects.
5805 func (m *Document) ResolveReferences(root string) (interface{}, error) {
5806 errors := make([]error, 0)
5808 _, err := m.Info.ResolveReferences(root)
5810 errors = append(errors, err)
5814 _, err := m.Paths.ResolveReferences(root)
5816 errors = append(errors, err)
5819 if m.Definitions != nil {
5820 _, err := m.Definitions.ResolveReferences(root)
5822 errors = append(errors, err)
5825 if m.Parameters != nil {
5826 _, err := m.Parameters.ResolveReferences(root)
5828 errors = append(errors, err)
5831 if m.Responses != nil {
5832 _, err := m.Responses.ResolveReferences(root)
5834 errors = append(errors, err)
5837 for _, item := range m.Security {
5839 _, err := item.ResolveReferences(root)
5841 errors = append(errors, err)
5845 if m.SecurityDefinitions != nil {
5846 _, err := m.SecurityDefinitions.ResolveReferences(root)
5848 errors = append(errors, err)
5851 for _, item := range m.Tags {
5853 _, err := item.ResolveReferences(root)
5855 errors = append(errors, err)
5859 if m.ExternalDocs != nil {
5860 _, err := m.ExternalDocs.ResolveReferences(root)
5862 errors = append(errors, err)
5865 for _, item := range m.VendorExtension {
5867 _, err := item.ResolveReferences(root)
5869 errors = append(errors, err)
5873 return nil, compiler.NewErrorGroupOrNil(errors)
5876 // ResolveReferences resolves references found inside Examples objects.
5877 func (m *Examples) ResolveReferences(root string) (interface{}, error) {
5878 errors := make([]error, 0)
5879 for _, item := range m.AdditionalProperties {
5881 _, err := item.ResolveReferences(root)
5883 errors = append(errors, err)
5887 return nil, compiler.NewErrorGroupOrNil(errors)
5890 // ResolveReferences resolves references found inside ExternalDocs objects.
5891 func (m *ExternalDocs) ResolveReferences(root string) (interface{}, error) {
5892 errors := make([]error, 0)
5893 for _, item := range m.VendorExtension {
5895 _, err := item.ResolveReferences(root)
5897 errors = append(errors, err)
5901 return nil, compiler.NewErrorGroupOrNil(errors)
5904 // ResolveReferences resolves references found inside FileSchema objects.
5905 func (m *FileSchema) ResolveReferences(root string) (interface{}, error) {
5906 errors := make([]error, 0)
5907 if m.Default != nil {
5908 _, err := m.Default.ResolveReferences(root)
5910 errors = append(errors, err)
5913 if m.ExternalDocs != nil {
5914 _, err := m.ExternalDocs.ResolveReferences(root)
5916 errors = append(errors, err)
5919 if m.Example != nil {
5920 _, err := m.Example.ResolveReferences(root)
5922 errors = append(errors, err)
5925 for _, item := range m.VendorExtension {
5927 _, err := item.ResolveReferences(root)
5929 errors = append(errors, err)
5933 return nil, compiler.NewErrorGroupOrNil(errors)
5936 // ResolveReferences resolves references found inside FormDataParameterSubSchema objects.
5937 func (m *FormDataParameterSubSchema) ResolveReferences(root string) (interface{}, error) {
5938 errors := make([]error, 0)
5940 _, err := m.Items.ResolveReferences(root)
5942 errors = append(errors, err)
5945 if m.Default != nil {
5946 _, err := m.Default.ResolveReferences(root)
5948 errors = append(errors, err)
5951 for _, item := range m.Enum {
5953 _, err := item.ResolveReferences(root)
5955 errors = append(errors, err)
5959 for _, item := range m.VendorExtension {
5961 _, err := item.ResolveReferences(root)
5963 errors = append(errors, err)
5967 return nil, compiler.NewErrorGroupOrNil(errors)
5970 // ResolveReferences resolves references found inside Header objects.
5971 func (m *Header) ResolveReferences(root string) (interface{}, error) {
5972 errors := make([]error, 0)
5974 _, err := m.Items.ResolveReferences(root)
5976 errors = append(errors, err)
5979 if m.Default != nil {
5980 _, err := m.Default.ResolveReferences(root)
5982 errors = append(errors, err)
5985 for _, item := range m.Enum {
5987 _, err := item.ResolveReferences(root)
5989 errors = append(errors, err)
5993 for _, item := range m.VendorExtension {
5995 _, err := item.ResolveReferences(root)
5997 errors = append(errors, err)
6001 return nil, compiler.NewErrorGroupOrNil(errors)
6004 // ResolveReferences resolves references found inside HeaderParameterSubSchema objects.
6005 func (m *HeaderParameterSubSchema) ResolveReferences(root string) (interface{}, error) {
6006 errors := make([]error, 0)
6008 _, err := m.Items.ResolveReferences(root)
6010 errors = append(errors, err)
6013 if m.Default != nil {
6014 _, err := m.Default.ResolveReferences(root)
6016 errors = append(errors, err)
6019 for _, item := range m.Enum {
6021 _, err := item.ResolveReferences(root)
6023 errors = append(errors, err)
6027 for _, item := range m.VendorExtension {
6029 _, err := item.ResolveReferences(root)
6031 errors = append(errors, err)
6035 return nil, compiler.NewErrorGroupOrNil(errors)
6038 // ResolveReferences resolves references found inside Headers objects.
6039 func (m *Headers) ResolveReferences(root string) (interface{}, error) {
6040 errors := make([]error, 0)
6041 for _, item := range m.AdditionalProperties {
6043 _, err := item.ResolveReferences(root)
6045 errors = append(errors, err)
6049 return nil, compiler.NewErrorGroupOrNil(errors)
6052 // ResolveReferences resolves references found inside Info objects.
6053 func (m *Info) ResolveReferences(root string) (interface{}, error) {
6054 errors := make([]error, 0)
6055 if m.Contact != nil {
6056 _, err := m.Contact.ResolveReferences(root)
6058 errors = append(errors, err)
6061 if m.License != nil {
6062 _, err := m.License.ResolveReferences(root)
6064 errors = append(errors, err)
6067 for _, item := range m.VendorExtension {
6069 _, err := item.ResolveReferences(root)
6071 errors = append(errors, err)
6075 return nil, compiler.NewErrorGroupOrNil(errors)
6078 // ResolveReferences resolves references found inside ItemsItem objects.
6079 func (m *ItemsItem) ResolveReferences(root string) (interface{}, error) {
6080 errors := make([]error, 0)
6081 for _, item := range m.Schema {
6083 _, err := item.ResolveReferences(root)
6085 errors = append(errors, err)
6089 return nil, compiler.NewErrorGroupOrNil(errors)
6092 // ResolveReferences resolves references found inside JsonReference objects.
6093 func (m *JsonReference) ResolveReferences(root string) (interface{}, error) {
6094 errors := make([]error, 0)
6096 info, err := compiler.ReadInfoForRef(root, m.XRef)
6101 replacement, err := NewJsonReference(info, nil)
6104 return m.ResolveReferences(root)
6109 return nil, compiler.NewErrorGroupOrNil(errors)
6112 // ResolveReferences resolves references found inside License objects.
6113 func (m *License) ResolveReferences(root string) (interface{}, error) {
6114 errors := make([]error, 0)
6115 for _, item := range m.VendorExtension {
6117 _, err := item.ResolveReferences(root)
6119 errors = append(errors, err)
6123 return nil, compiler.NewErrorGroupOrNil(errors)
6126 // ResolveReferences resolves references found inside NamedAny objects.
6127 func (m *NamedAny) ResolveReferences(root string) (interface{}, error) {
6128 errors := make([]error, 0)
6130 _, err := m.Value.ResolveReferences(root)
6132 errors = append(errors, err)
6135 return nil, compiler.NewErrorGroupOrNil(errors)
6138 // ResolveReferences resolves references found inside NamedHeader objects.
6139 func (m *NamedHeader) ResolveReferences(root string) (interface{}, error) {
6140 errors := make([]error, 0)
6142 _, err := m.Value.ResolveReferences(root)
6144 errors = append(errors, err)
6147 return nil, compiler.NewErrorGroupOrNil(errors)
6150 // ResolveReferences resolves references found inside NamedParameter objects.
6151 func (m *NamedParameter) ResolveReferences(root string) (interface{}, error) {
6152 errors := make([]error, 0)
6154 _, err := m.Value.ResolveReferences(root)
6156 errors = append(errors, err)
6159 return nil, compiler.NewErrorGroupOrNil(errors)
6162 // ResolveReferences resolves references found inside NamedPathItem objects.
6163 func (m *NamedPathItem) ResolveReferences(root string) (interface{}, error) {
6164 errors := make([]error, 0)
6166 _, err := m.Value.ResolveReferences(root)
6168 errors = append(errors, err)
6171 return nil, compiler.NewErrorGroupOrNil(errors)
6174 // ResolveReferences resolves references found inside NamedResponse objects.
6175 func (m *NamedResponse) ResolveReferences(root string) (interface{}, error) {
6176 errors := make([]error, 0)
6178 _, err := m.Value.ResolveReferences(root)
6180 errors = append(errors, err)
6183 return nil, compiler.NewErrorGroupOrNil(errors)
6186 // ResolveReferences resolves references found inside NamedResponseValue objects.
6187 func (m *NamedResponseValue) ResolveReferences(root string) (interface{}, error) {
6188 errors := make([]error, 0)
6190 _, err := m.Value.ResolveReferences(root)
6192 errors = append(errors, err)
6195 return nil, compiler.NewErrorGroupOrNil(errors)
6198 // ResolveReferences resolves references found inside NamedSchema objects.
6199 func (m *NamedSchema) ResolveReferences(root string) (interface{}, error) {
6200 errors := make([]error, 0)
6202 _, err := m.Value.ResolveReferences(root)
6204 errors = append(errors, err)
6207 return nil, compiler.NewErrorGroupOrNil(errors)
6210 // ResolveReferences resolves references found inside NamedSecurityDefinitionsItem objects.
6211 func (m *NamedSecurityDefinitionsItem) ResolveReferences(root string) (interface{}, error) {
6212 errors := make([]error, 0)
6214 _, err := m.Value.ResolveReferences(root)
6216 errors = append(errors, err)
6219 return nil, compiler.NewErrorGroupOrNil(errors)
6222 // ResolveReferences resolves references found inside NamedString objects.
6223 func (m *NamedString) ResolveReferences(root string) (interface{}, error) {
6224 errors := make([]error, 0)
6225 return nil, compiler.NewErrorGroupOrNil(errors)
6228 // ResolveReferences resolves references found inside NamedStringArray objects.
6229 func (m *NamedStringArray) ResolveReferences(root string) (interface{}, error) {
6230 errors := make([]error, 0)
6232 _, err := m.Value.ResolveReferences(root)
6234 errors = append(errors, err)
6237 return nil, compiler.NewErrorGroupOrNil(errors)
6240 // ResolveReferences resolves references found inside NonBodyParameter objects.
6241 func (m *NonBodyParameter) ResolveReferences(root string) (interface{}, error) {
6242 errors := make([]error, 0)
6244 p, ok := m.Oneof.(*NonBodyParameter_HeaderParameterSubSchema)
6246 _, err := p.HeaderParameterSubSchema.ResolveReferences(root)
6253 p, ok := m.Oneof.(*NonBodyParameter_FormDataParameterSubSchema)
6255 _, err := p.FormDataParameterSubSchema.ResolveReferences(root)
6262 p, ok := m.Oneof.(*NonBodyParameter_QueryParameterSubSchema)
6264 _, err := p.QueryParameterSubSchema.ResolveReferences(root)
6271 p, ok := m.Oneof.(*NonBodyParameter_PathParameterSubSchema)
6273 _, err := p.PathParameterSubSchema.ResolveReferences(root)
6279 return nil, compiler.NewErrorGroupOrNil(errors)
6282 // ResolveReferences resolves references found inside Oauth2AccessCodeSecurity objects.
6283 func (m *Oauth2AccessCodeSecurity) ResolveReferences(root string) (interface{}, error) {
6284 errors := make([]error, 0)
6285 if m.Scopes != nil {
6286 _, err := m.Scopes.ResolveReferences(root)
6288 errors = append(errors, err)
6291 for _, item := range m.VendorExtension {
6293 _, err := item.ResolveReferences(root)
6295 errors = append(errors, err)
6299 return nil, compiler.NewErrorGroupOrNil(errors)
6302 // ResolveReferences resolves references found inside Oauth2ApplicationSecurity objects.
6303 func (m *Oauth2ApplicationSecurity) ResolveReferences(root string) (interface{}, error) {
6304 errors := make([]error, 0)
6305 if m.Scopes != nil {
6306 _, err := m.Scopes.ResolveReferences(root)
6308 errors = append(errors, err)
6311 for _, item := range m.VendorExtension {
6313 _, err := item.ResolveReferences(root)
6315 errors = append(errors, err)
6319 return nil, compiler.NewErrorGroupOrNil(errors)
6322 // ResolveReferences resolves references found inside Oauth2ImplicitSecurity objects.
6323 func (m *Oauth2ImplicitSecurity) ResolveReferences(root string) (interface{}, error) {
6324 errors := make([]error, 0)
6325 if m.Scopes != nil {
6326 _, err := m.Scopes.ResolveReferences(root)
6328 errors = append(errors, err)
6331 for _, item := range m.VendorExtension {
6333 _, err := item.ResolveReferences(root)
6335 errors = append(errors, err)
6339 return nil, compiler.NewErrorGroupOrNil(errors)
6342 // ResolveReferences resolves references found inside Oauth2PasswordSecurity objects.
6343 func (m *Oauth2PasswordSecurity) ResolveReferences(root string) (interface{}, error) {
6344 errors := make([]error, 0)
6345 if m.Scopes != nil {
6346 _, err := m.Scopes.ResolveReferences(root)
6348 errors = append(errors, err)
6351 for _, item := range m.VendorExtension {
6353 _, err := item.ResolveReferences(root)
6355 errors = append(errors, err)
6359 return nil, compiler.NewErrorGroupOrNil(errors)
6362 // ResolveReferences resolves references found inside Oauth2Scopes objects.
6363 func (m *Oauth2Scopes) ResolveReferences(root string) (interface{}, error) {
6364 errors := make([]error, 0)
6365 for _, item := range m.AdditionalProperties {
6367 _, err := item.ResolveReferences(root)
6369 errors = append(errors, err)
6373 return nil, compiler.NewErrorGroupOrNil(errors)
6376 // ResolveReferences resolves references found inside Operation objects.
6377 func (m *Operation) ResolveReferences(root string) (interface{}, error) {
6378 errors := make([]error, 0)
6379 if m.ExternalDocs != nil {
6380 _, err := m.ExternalDocs.ResolveReferences(root)
6382 errors = append(errors, err)
6385 for _, item := range m.Parameters {
6387 _, err := item.ResolveReferences(root)
6389 errors = append(errors, err)
6393 if m.Responses != nil {
6394 _, err := m.Responses.ResolveReferences(root)
6396 errors = append(errors, err)
6399 for _, item := range m.Security {
6401 _, err := item.ResolveReferences(root)
6403 errors = append(errors, err)
6407 for _, item := range m.VendorExtension {
6409 _, err := item.ResolveReferences(root)
6411 errors = append(errors, err)
6415 return nil, compiler.NewErrorGroupOrNil(errors)
6418 // ResolveReferences resolves references found inside Parameter objects.
6419 func (m *Parameter) ResolveReferences(root string) (interface{}, error) {
6420 errors := make([]error, 0)
6422 p, ok := m.Oneof.(*Parameter_BodyParameter)
6424 _, err := p.BodyParameter.ResolveReferences(root)
6431 p, ok := m.Oneof.(*Parameter_NonBodyParameter)
6433 _, err := p.NonBodyParameter.ResolveReferences(root)
6439 return nil, compiler.NewErrorGroupOrNil(errors)
6442 // ResolveReferences resolves references found inside ParameterDefinitions objects.
6443 func (m *ParameterDefinitions) ResolveReferences(root string) (interface{}, error) {
6444 errors := make([]error, 0)
6445 for _, item := range m.AdditionalProperties {
6447 _, err := item.ResolveReferences(root)
6449 errors = append(errors, err)
6453 return nil, compiler.NewErrorGroupOrNil(errors)
6456 // ResolveReferences resolves references found inside ParametersItem objects.
6457 func (m *ParametersItem) ResolveReferences(root string) (interface{}, error) {
6458 errors := make([]error, 0)
6460 p, ok := m.Oneof.(*ParametersItem_Parameter)
6462 _, err := p.Parameter.ResolveReferences(root)
6469 p, ok := m.Oneof.(*ParametersItem_JsonReference)
6471 info, err := p.JsonReference.ResolveReferences(root)
6474 } else if info != nil {
6475 n, err := NewParametersItem(info, nil)
6478 } else if n != nil {
6485 return nil, compiler.NewErrorGroupOrNil(errors)
6488 // ResolveReferences resolves references found inside PathItem objects.
6489 func (m *PathItem) ResolveReferences(root string) (interface{}, error) {
6490 errors := make([]error, 0)
6492 info, err := compiler.ReadInfoForRef(root, m.XRef)
6497 replacement, err := NewPathItem(info, nil)
6500 return m.ResolveReferences(root)
6506 _, err := m.Get.ResolveReferences(root)
6508 errors = append(errors, err)
6512 _, err := m.Put.ResolveReferences(root)
6514 errors = append(errors, err)
6518 _, err := m.Post.ResolveReferences(root)
6520 errors = append(errors, err)
6523 if m.Delete != nil {
6524 _, err := m.Delete.ResolveReferences(root)
6526 errors = append(errors, err)
6529 if m.Options != nil {
6530 _, err := m.Options.ResolveReferences(root)
6532 errors = append(errors, err)
6536 _, err := m.Head.ResolveReferences(root)
6538 errors = append(errors, err)
6542 _, err := m.Patch.ResolveReferences(root)
6544 errors = append(errors, err)
6547 for _, item := range m.Parameters {
6549 _, err := item.ResolveReferences(root)
6551 errors = append(errors, err)
6555 for _, item := range m.VendorExtension {
6557 _, err := item.ResolveReferences(root)
6559 errors = append(errors, err)
6563 return nil, compiler.NewErrorGroupOrNil(errors)
6566 // ResolveReferences resolves references found inside PathParameterSubSchema objects.
6567 func (m *PathParameterSubSchema) ResolveReferences(root string) (interface{}, error) {
6568 errors := make([]error, 0)
6570 _, err := m.Items.ResolveReferences(root)
6572 errors = append(errors, err)
6575 if m.Default != nil {
6576 _, err := m.Default.ResolveReferences(root)
6578 errors = append(errors, err)
6581 for _, item := range m.Enum {
6583 _, err := item.ResolveReferences(root)
6585 errors = append(errors, err)
6589 for _, item := range m.VendorExtension {
6591 _, err := item.ResolveReferences(root)
6593 errors = append(errors, err)
6597 return nil, compiler.NewErrorGroupOrNil(errors)
6600 // ResolveReferences resolves references found inside Paths objects.
6601 func (m *Paths) ResolveReferences(root string) (interface{}, error) {
6602 errors := make([]error, 0)
6603 for _, item := range m.VendorExtension {
6605 _, err := item.ResolveReferences(root)
6607 errors = append(errors, err)
6611 for _, item := range m.Path {
6613 _, err := item.ResolveReferences(root)
6615 errors = append(errors, err)
6619 return nil, compiler.NewErrorGroupOrNil(errors)
6622 // ResolveReferences resolves references found inside PrimitivesItems objects.
6623 func (m *PrimitivesItems) ResolveReferences(root string) (interface{}, error) {
6624 errors := make([]error, 0)
6626 _, err := m.Items.ResolveReferences(root)
6628 errors = append(errors, err)
6631 if m.Default != nil {
6632 _, err := m.Default.ResolveReferences(root)
6634 errors = append(errors, err)
6637 for _, item := range m.Enum {
6639 _, err := item.ResolveReferences(root)
6641 errors = append(errors, err)
6645 for _, item := range m.VendorExtension {
6647 _, err := item.ResolveReferences(root)
6649 errors = append(errors, err)
6653 return nil, compiler.NewErrorGroupOrNil(errors)
6656 // ResolveReferences resolves references found inside Properties objects.
6657 func (m *Properties) ResolveReferences(root string) (interface{}, error) {
6658 errors := make([]error, 0)
6659 for _, item := range m.AdditionalProperties {
6661 _, err := item.ResolveReferences(root)
6663 errors = append(errors, err)
6667 return nil, compiler.NewErrorGroupOrNil(errors)
6670 // ResolveReferences resolves references found inside QueryParameterSubSchema objects.
6671 func (m *QueryParameterSubSchema) ResolveReferences(root string) (interface{}, error) {
6672 errors := make([]error, 0)
6674 _, err := m.Items.ResolveReferences(root)
6676 errors = append(errors, err)
6679 if m.Default != nil {
6680 _, err := m.Default.ResolveReferences(root)
6682 errors = append(errors, err)
6685 for _, item := range m.Enum {
6687 _, err := item.ResolveReferences(root)
6689 errors = append(errors, err)
6693 for _, item := range m.VendorExtension {
6695 _, err := item.ResolveReferences(root)
6697 errors = append(errors, err)
6701 return nil, compiler.NewErrorGroupOrNil(errors)
6704 // ResolveReferences resolves references found inside Response objects.
6705 func (m *Response) ResolveReferences(root string) (interface{}, error) {
6706 errors := make([]error, 0)
6707 if m.Schema != nil {
6708 _, err := m.Schema.ResolveReferences(root)
6710 errors = append(errors, err)
6713 if m.Headers != nil {
6714 _, err := m.Headers.ResolveReferences(root)
6716 errors = append(errors, err)
6719 if m.Examples != nil {
6720 _, err := m.Examples.ResolveReferences(root)
6722 errors = append(errors, err)
6725 for _, item := range m.VendorExtension {
6727 _, err := item.ResolveReferences(root)
6729 errors = append(errors, err)
6733 return nil, compiler.NewErrorGroupOrNil(errors)
6736 // ResolveReferences resolves references found inside ResponseDefinitions objects.
6737 func (m *ResponseDefinitions) ResolveReferences(root string) (interface{}, error) {
6738 errors := make([]error, 0)
6739 for _, item := range m.AdditionalProperties {
6741 _, err := item.ResolveReferences(root)
6743 errors = append(errors, err)
6747 return nil, compiler.NewErrorGroupOrNil(errors)
6750 // ResolveReferences resolves references found inside ResponseValue objects.
6751 func (m *ResponseValue) ResolveReferences(root string) (interface{}, error) {
6752 errors := make([]error, 0)
6754 p, ok := m.Oneof.(*ResponseValue_Response)
6756 _, err := p.Response.ResolveReferences(root)
6763 p, ok := m.Oneof.(*ResponseValue_JsonReference)
6765 info, err := p.JsonReference.ResolveReferences(root)
6768 } else if info != nil {
6769 n, err := NewResponseValue(info, nil)
6772 } else if n != nil {
6779 return nil, compiler.NewErrorGroupOrNil(errors)
6782 // ResolveReferences resolves references found inside Responses objects.
6783 func (m *Responses) ResolveReferences(root string) (interface{}, error) {
6784 errors := make([]error, 0)
6785 for _, item := range m.ResponseCode {
6787 _, err := item.ResolveReferences(root)
6789 errors = append(errors, err)
6793 for _, item := range m.VendorExtension {
6795 _, err := item.ResolveReferences(root)
6797 errors = append(errors, err)
6801 return nil, compiler.NewErrorGroupOrNil(errors)
6804 // ResolveReferences resolves references found inside Schema objects.
6805 func (m *Schema) ResolveReferences(root string) (interface{}, error) {
6806 errors := make([]error, 0)
6808 info, err := compiler.ReadInfoForRef(root, m.XRef)
6813 replacement, err := NewSchema(info, nil)
6816 return m.ResolveReferences(root)
6821 if m.Default != nil {
6822 _, err := m.Default.ResolveReferences(root)
6824 errors = append(errors, err)
6827 for _, item := range m.Enum {
6829 _, err := item.ResolveReferences(root)
6831 errors = append(errors, err)
6835 if m.AdditionalProperties != nil {
6836 _, err := m.AdditionalProperties.ResolveReferences(root)
6838 errors = append(errors, err)
6842 _, err := m.Type.ResolveReferences(root)
6844 errors = append(errors, err)
6848 _, err := m.Items.ResolveReferences(root)
6850 errors = append(errors, err)
6853 for _, item := range m.AllOf {
6855 _, err := item.ResolveReferences(root)
6857 errors = append(errors, err)
6861 if m.Properties != nil {
6862 _, err := m.Properties.ResolveReferences(root)
6864 errors = append(errors, err)
6868 _, err := m.Xml.ResolveReferences(root)
6870 errors = append(errors, err)
6873 if m.ExternalDocs != nil {
6874 _, err := m.ExternalDocs.ResolveReferences(root)
6876 errors = append(errors, err)
6879 if m.Example != nil {
6880 _, err := m.Example.ResolveReferences(root)
6882 errors = append(errors, err)
6885 for _, item := range m.VendorExtension {
6887 _, err := item.ResolveReferences(root)
6889 errors = append(errors, err)
6893 return nil, compiler.NewErrorGroupOrNil(errors)
6896 // ResolveReferences resolves references found inside SchemaItem objects.
6897 func (m *SchemaItem) ResolveReferences(root string) (interface{}, error) {
6898 errors := make([]error, 0)
6900 p, ok := m.Oneof.(*SchemaItem_Schema)
6902 _, err := p.Schema.ResolveReferences(root)
6909 p, ok := m.Oneof.(*SchemaItem_FileSchema)
6911 _, err := p.FileSchema.ResolveReferences(root)
6917 return nil, compiler.NewErrorGroupOrNil(errors)
6920 // ResolveReferences resolves references found inside SecurityDefinitions objects.
6921 func (m *SecurityDefinitions) ResolveReferences(root string) (interface{}, error) {
6922 errors := make([]error, 0)
6923 for _, item := range m.AdditionalProperties {
6925 _, err := item.ResolveReferences(root)
6927 errors = append(errors, err)
6931 return nil, compiler.NewErrorGroupOrNil(errors)
6934 // ResolveReferences resolves references found inside SecurityDefinitionsItem objects.
6935 func (m *SecurityDefinitionsItem) ResolveReferences(root string) (interface{}, error) {
6936 errors := make([]error, 0)
6938 p, ok := m.Oneof.(*SecurityDefinitionsItem_BasicAuthenticationSecurity)
6940 _, err := p.BasicAuthenticationSecurity.ResolveReferences(root)
6947 p, ok := m.Oneof.(*SecurityDefinitionsItem_ApiKeySecurity)
6949 _, err := p.ApiKeySecurity.ResolveReferences(root)
6956 p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2ImplicitSecurity)
6958 _, err := p.Oauth2ImplicitSecurity.ResolveReferences(root)
6965 p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2PasswordSecurity)
6967 _, err := p.Oauth2PasswordSecurity.ResolveReferences(root)
6974 p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2ApplicationSecurity)
6976 _, err := p.Oauth2ApplicationSecurity.ResolveReferences(root)
6983 p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2AccessCodeSecurity)
6985 _, err := p.Oauth2AccessCodeSecurity.ResolveReferences(root)
6991 return nil, compiler.NewErrorGroupOrNil(errors)
6994 // ResolveReferences resolves references found inside SecurityRequirement objects.
6995 func (m *SecurityRequirement) ResolveReferences(root string) (interface{}, error) {
6996 errors := make([]error, 0)
6997 for _, item := range m.AdditionalProperties {
6999 _, err := item.ResolveReferences(root)
7001 errors = append(errors, err)
7005 return nil, compiler.NewErrorGroupOrNil(errors)
7008 // ResolveReferences resolves references found inside StringArray objects.
7009 func (m *StringArray) ResolveReferences(root string) (interface{}, error) {
7010 errors := make([]error, 0)
7011 return nil, compiler.NewErrorGroupOrNil(errors)
7014 // ResolveReferences resolves references found inside Tag objects.
7015 func (m *Tag) ResolveReferences(root string) (interface{}, error) {
7016 errors := make([]error, 0)
7017 if m.ExternalDocs != nil {
7018 _, err := m.ExternalDocs.ResolveReferences(root)
7020 errors = append(errors, err)
7023 for _, item := range m.VendorExtension {
7025 _, err := item.ResolveReferences(root)
7027 errors = append(errors, err)
7031 return nil, compiler.NewErrorGroupOrNil(errors)
7034 // ResolveReferences resolves references found inside TypeItem objects.
7035 func (m *TypeItem) ResolveReferences(root string) (interface{}, error) {
7036 errors := make([]error, 0)
7037 return nil, compiler.NewErrorGroupOrNil(errors)
7040 // ResolveReferences resolves references found inside VendorExtension objects.
7041 func (m *VendorExtension) ResolveReferences(root string) (interface{}, error) {
7042 errors := make([]error, 0)
7043 for _, item := range m.AdditionalProperties {
7045 _, err := item.ResolveReferences(root)
7047 errors = append(errors, err)
7051 return nil, compiler.NewErrorGroupOrNil(errors)
7054 // ResolveReferences resolves references found inside Xml objects.
7055 func (m *Xml) ResolveReferences(root string) (interface{}, error) {
7056 errors := make([]error, 0)
7057 for _, item := range m.VendorExtension {
7059 _, err := item.ResolveReferences(root)
7061 errors = append(errors, err)
7065 return nil, compiler.NewErrorGroupOrNil(errors)
7068 // ToRawInfo returns a description of AdditionalPropertiesItem suitable for JSON or YAML export.
7069 func (m *AdditionalPropertiesItem) ToRawInfo() interface{} {
7071 // AdditionalPropertiesItem
7072 // {Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7075 return v0.ToRawInfo()
7077 // {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7078 if v1, ok := m.GetOneof().(*AdditionalPropertiesItem_Boolean); ok {
7084 // ToRawInfo returns a description of Any suitable for JSON or YAML export.
7085 func (m *Any) ToRawInfo() interface{} {
7087 var info1 []yaml.MapSlice
7088 err = yaml.Unmarshal([]byte(m.Yaml), &info1)
7092 var info2 yaml.MapSlice
7093 err = yaml.Unmarshal([]byte(m.Yaml), &info2)
7097 var info3 interface{}
7098 err = yaml.Unmarshal([]byte(m.Yaml), &info3)
7105 // ToRawInfo returns a description of ApiKeySecurity suitable for JSON or YAML export.
7106 func (m *ApiKeySecurity) ToRawInfo() interface{} {
7107 info := yaml.MapSlice{}
7109 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7112 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7115 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
7117 if m.Description != "" {
7118 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7120 if m.VendorExtension != nil {
7121 for _, item := range m.VendorExtension {
7122 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7125 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7129 // ToRawInfo returns a description of BasicAuthenticationSecurity suitable for JSON or YAML export.
7130 func (m *BasicAuthenticationSecurity) ToRawInfo() interface{} {
7131 info := yaml.MapSlice{}
7133 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7135 if m.Description != "" {
7136 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7138 if m.VendorExtension != nil {
7139 for _, item := range m.VendorExtension {
7140 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7143 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7147 // ToRawInfo returns a description of BodyParameter suitable for JSON or YAML export.
7148 func (m *BodyParameter) ToRawInfo() interface{} {
7149 info := yaml.MapSlice{}
7150 if m.Description != "" {
7151 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7154 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7157 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
7159 if m.Required != false {
7160 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
7162 if m.Schema != nil {
7163 info = append(info, yaml.MapItem{Key: "schema", Value: m.Schema.ToRawInfo()})
7165 // &{Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7166 if m.VendorExtension != nil {
7167 for _, item := range m.VendorExtension {
7168 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7171 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7175 // ToRawInfo returns a description of Contact suitable for JSON or YAML export.
7176 func (m *Contact) ToRawInfo() interface{} {
7177 info := yaml.MapSlice{}
7179 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7182 info = append(info, yaml.MapItem{Key: "url", Value: m.Url})
7185 info = append(info, yaml.MapItem{Key: "email", Value: m.Email})
7187 if m.VendorExtension != nil {
7188 for _, item := range m.VendorExtension {
7189 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7192 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7196 // ToRawInfo returns a description of Default suitable for JSON or YAML export.
7197 func (m *Default) ToRawInfo() interface{} {
7198 info := yaml.MapSlice{}
7199 if m.AdditionalProperties != nil {
7200 for _, item := range m.AdditionalProperties {
7201 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7204 // &{Name:additionalProperties Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern: Implicit:false Description:}
7208 // ToRawInfo returns a description of Definitions suitable for JSON or YAML export.
7209 func (m *Definitions) ToRawInfo() interface{} {
7210 info := yaml.MapSlice{}
7211 if m.AdditionalProperties != nil {
7212 for _, item := range m.AdditionalProperties {
7213 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7216 // &{Name:additionalProperties Type:NamedSchema StringEnumValues:[] MapType:Schema Repeated:true Pattern: Implicit:true Description:}
7220 // ToRawInfo returns a description of Document suitable for JSON or YAML export.
7221 func (m *Document) ToRawInfo() interface{} {
7222 info := yaml.MapSlice{}
7223 if m.Swagger != "" {
7224 info = append(info, yaml.MapItem{Key: "swagger", Value: m.Swagger})
7227 info = append(info, yaml.MapItem{Key: "info", Value: m.Info.ToRawInfo()})
7229 // &{Name:info Type:Info StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7231 info = append(info, yaml.MapItem{Key: "host", Value: m.Host})
7233 if m.BasePath != "" {
7234 info = append(info, yaml.MapItem{Key: "basePath", Value: m.BasePath})
7236 if len(m.Schemes) != 0 {
7237 info = append(info, yaml.MapItem{Key: "schemes", Value: m.Schemes})
7239 if len(m.Consumes) != 0 {
7240 info = append(info, yaml.MapItem{Key: "consumes", Value: m.Consumes})
7242 if len(m.Produces) != 0 {
7243 info = append(info, yaml.MapItem{Key: "produces", Value: m.Produces})
7246 info = append(info, yaml.MapItem{Key: "paths", Value: m.Paths.ToRawInfo()})
7248 // &{Name:paths Type:Paths StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7249 if m.Definitions != nil {
7250 info = append(info, yaml.MapItem{Key: "definitions", Value: m.Definitions.ToRawInfo()})
7252 // &{Name:definitions Type:Definitions StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7253 if m.Parameters != nil {
7254 info = append(info, yaml.MapItem{Key: "parameters", Value: m.Parameters.ToRawInfo()})
7256 // &{Name:parameters Type:ParameterDefinitions StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7257 if m.Responses != nil {
7258 info = append(info, yaml.MapItem{Key: "responses", Value: m.Responses.ToRawInfo()})
7260 // &{Name:responses Type:ResponseDefinitions StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7261 if len(m.Security) != 0 {
7262 items := make([]interface{}, 0)
7263 for _, item := range m.Security {
7264 items = append(items, item.ToRawInfo())
7266 info = append(info, yaml.MapItem{Key: "security", Value: items})
7268 // &{Name:security Type:SecurityRequirement StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7269 if m.SecurityDefinitions != nil {
7270 info = append(info, yaml.MapItem{Key: "securityDefinitions", Value: m.SecurityDefinitions.ToRawInfo()})
7272 // &{Name:securityDefinitions Type:SecurityDefinitions StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7273 if len(m.Tags) != 0 {
7274 items := make([]interface{}, 0)
7275 for _, item := range m.Tags {
7276 items = append(items, item.ToRawInfo())
7278 info = append(info, yaml.MapItem{Key: "tags", Value: items})
7280 // &{Name:tags Type:Tag StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7281 if m.ExternalDocs != nil {
7282 info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawInfo()})
7284 // &{Name:externalDocs Type:ExternalDocs StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7285 if m.VendorExtension != nil {
7286 for _, item := range m.VendorExtension {
7287 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7290 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7294 // ToRawInfo returns a description of Examples suitable for JSON or YAML export.
7295 func (m *Examples) ToRawInfo() interface{} {
7296 info := yaml.MapSlice{}
7297 if m.AdditionalProperties != nil {
7298 for _, item := range m.AdditionalProperties {
7299 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7302 // &{Name:additionalProperties Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern: Implicit:true Description:}
7306 // ToRawInfo returns a description of ExternalDocs suitable for JSON or YAML export.
7307 func (m *ExternalDocs) ToRawInfo() interface{} {
7308 info := yaml.MapSlice{}
7309 if m.Description != "" {
7310 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7313 info = append(info, yaml.MapItem{Key: "url", Value: m.Url})
7315 if m.VendorExtension != nil {
7316 for _, item := range m.VendorExtension {
7317 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7320 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7324 // ToRawInfo returns a description of FileSchema suitable for JSON or YAML export.
7325 func (m *FileSchema) ToRawInfo() interface{} {
7326 info := yaml.MapSlice{}
7328 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
7331 info = append(info, yaml.MapItem{Key: "title", Value: m.Title})
7333 if m.Description != "" {
7334 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7336 if m.Default != nil {
7337 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
7339 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7340 if len(m.Required) != 0 {
7341 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
7344 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7346 if m.ReadOnly != false {
7347 info = append(info, yaml.MapItem{Key: "readOnly", Value: m.ReadOnly})
7349 if m.ExternalDocs != nil {
7350 info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawInfo()})
7352 // &{Name:externalDocs Type:ExternalDocs StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7353 if m.Example != nil {
7354 info = append(info, yaml.MapItem{Key: "example", Value: m.Example.ToRawInfo()})
7356 // &{Name:example Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7357 if m.VendorExtension != nil {
7358 for _, item := range m.VendorExtension {
7359 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7362 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7366 // ToRawInfo returns a description of FormDataParameterSubSchema suitable for JSON or YAML export.
7367 func (m *FormDataParameterSubSchema) ToRawInfo() interface{} {
7368 info := yaml.MapSlice{}
7369 if m.Required != false {
7370 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
7373 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
7375 if m.Description != "" {
7376 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7379 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7381 if m.AllowEmptyValue != false {
7382 info = append(info, yaml.MapItem{Key: "allowEmptyValue", Value: m.AllowEmptyValue})
7385 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7388 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
7391 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
7393 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7394 if m.CollectionFormat != "" {
7395 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
7397 if m.Default != nil {
7398 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
7400 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7401 if m.Maximum != 0.0 {
7402 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
7404 if m.ExclusiveMaximum != false {
7405 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
7407 if m.Minimum != 0.0 {
7408 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
7410 if m.ExclusiveMinimum != false {
7411 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
7413 if m.MaxLength != 0 {
7414 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
7416 if m.MinLength != 0 {
7417 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
7419 if m.Pattern != "" {
7420 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
7422 if m.MaxItems != 0 {
7423 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
7425 if m.MinItems != 0 {
7426 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
7428 if m.UniqueItems != false {
7429 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
7431 if len(m.Enum) != 0 {
7432 items := make([]interface{}, 0)
7433 for _, item := range m.Enum {
7434 items = append(items, item.ToRawInfo())
7436 info = append(info, yaml.MapItem{Key: "enum", Value: items})
7438 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7439 if m.MultipleOf != 0.0 {
7440 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
7442 if m.VendorExtension != nil {
7443 for _, item := range m.VendorExtension {
7444 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7447 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7451 // ToRawInfo returns a description of Header suitable for JSON or YAML export.
7452 func (m *Header) ToRawInfo() interface{} {
7453 info := yaml.MapSlice{}
7455 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7458 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
7461 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
7463 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7464 if m.CollectionFormat != "" {
7465 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
7467 if m.Default != nil {
7468 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
7470 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7471 if m.Maximum != 0.0 {
7472 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
7474 if m.ExclusiveMaximum != false {
7475 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
7477 if m.Minimum != 0.0 {
7478 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
7480 if m.ExclusiveMinimum != false {
7481 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
7483 if m.MaxLength != 0 {
7484 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
7486 if m.MinLength != 0 {
7487 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
7489 if m.Pattern != "" {
7490 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
7492 if m.MaxItems != 0 {
7493 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
7495 if m.MinItems != 0 {
7496 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
7498 if m.UniqueItems != false {
7499 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
7501 if len(m.Enum) != 0 {
7502 items := make([]interface{}, 0)
7503 for _, item := range m.Enum {
7504 items = append(items, item.ToRawInfo())
7506 info = append(info, yaml.MapItem{Key: "enum", Value: items})
7508 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7509 if m.MultipleOf != 0.0 {
7510 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
7512 if m.Description != "" {
7513 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7515 if m.VendorExtension != nil {
7516 for _, item := range m.VendorExtension {
7517 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7520 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7524 // ToRawInfo returns a description of HeaderParameterSubSchema suitable for JSON or YAML export.
7525 func (m *HeaderParameterSubSchema) ToRawInfo() interface{} {
7526 info := yaml.MapSlice{}
7527 if m.Required != false {
7528 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
7531 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
7533 if m.Description != "" {
7534 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7537 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7540 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7543 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
7546 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
7548 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7549 if m.CollectionFormat != "" {
7550 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
7552 if m.Default != nil {
7553 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
7555 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7556 if m.Maximum != 0.0 {
7557 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
7559 if m.ExclusiveMaximum != false {
7560 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
7562 if m.Minimum != 0.0 {
7563 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
7565 if m.ExclusiveMinimum != false {
7566 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
7568 if m.MaxLength != 0 {
7569 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
7571 if m.MinLength != 0 {
7572 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
7574 if m.Pattern != "" {
7575 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
7577 if m.MaxItems != 0 {
7578 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
7580 if m.MinItems != 0 {
7581 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
7583 if m.UniqueItems != false {
7584 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
7586 if len(m.Enum) != 0 {
7587 items := make([]interface{}, 0)
7588 for _, item := range m.Enum {
7589 items = append(items, item.ToRawInfo())
7591 info = append(info, yaml.MapItem{Key: "enum", Value: items})
7593 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7594 if m.MultipleOf != 0.0 {
7595 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
7597 if m.VendorExtension != nil {
7598 for _, item := range m.VendorExtension {
7599 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7602 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7606 // ToRawInfo returns a description of Headers suitable for JSON or YAML export.
7607 func (m *Headers) ToRawInfo() interface{} {
7608 info := yaml.MapSlice{}
7609 if m.AdditionalProperties != nil {
7610 for _, item := range m.AdditionalProperties {
7611 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7614 // &{Name:additionalProperties Type:NamedHeader StringEnumValues:[] MapType:Header Repeated:true Pattern: Implicit:true Description:}
7618 // ToRawInfo returns a description of Info suitable for JSON or YAML export.
7619 func (m *Info) ToRawInfo() interface{} {
7620 info := yaml.MapSlice{}
7622 info = append(info, yaml.MapItem{Key: "title", Value: m.Title})
7624 if m.Version != "" {
7625 info = append(info, yaml.MapItem{Key: "version", Value: m.Version})
7627 if m.Description != "" {
7628 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7630 if m.TermsOfService != "" {
7631 info = append(info, yaml.MapItem{Key: "termsOfService", Value: m.TermsOfService})
7633 if m.Contact != nil {
7634 info = append(info, yaml.MapItem{Key: "contact", Value: m.Contact.ToRawInfo()})
7636 // &{Name:contact Type:Contact StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7637 if m.License != nil {
7638 info = append(info, yaml.MapItem{Key: "license", Value: m.License.ToRawInfo()})
7640 // &{Name:license Type:License StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7641 if m.VendorExtension != nil {
7642 for _, item := range m.VendorExtension {
7643 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7646 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7650 // ToRawInfo returns a description of ItemsItem suitable for JSON or YAML export.
7651 func (m *ItemsItem) ToRawInfo() interface{} {
7652 info := yaml.MapSlice{}
7653 if len(m.Schema) != 0 {
7654 items := make([]interface{}, 0)
7655 for _, item := range m.Schema {
7656 items = append(items, item.ToRawInfo())
7658 info = append(info, yaml.MapItem{Key: "schema", Value: items})
7660 // &{Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7664 // ToRawInfo returns a description of JsonReference suitable for JSON or YAML export.
7665 func (m *JsonReference) ToRawInfo() interface{} {
7666 info := yaml.MapSlice{}
7668 info = append(info, yaml.MapItem{Key: "$ref", Value: m.XRef})
7670 if m.Description != "" {
7671 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7676 // ToRawInfo returns a description of License suitable for JSON or YAML export.
7677 func (m *License) ToRawInfo() interface{} {
7678 info := yaml.MapSlice{}
7680 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7683 info = append(info, yaml.MapItem{Key: "url", Value: m.Url})
7685 if m.VendorExtension != nil {
7686 for _, item := range m.VendorExtension {
7687 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7690 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7694 // ToRawInfo returns a description of NamedAny suitable for JSON or YAML export.
7695 func (m *NamedAny) ToRawInfo() interface{} {
7696 info := yaml.MapSlice{}
7698 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7700 // &{Name:value Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7704 // ToRawInfo returns a description of NamedHeader suitable for JSON or YAML export.
7705 func (m *NamedHeader) ToRawInfo() interface{} {
7706 info := yaml.MapSlice{}
7708 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7710 // &{Name:value Type:Header StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7714 // ToRawInfo returns a description of NamedParameter suitable for JSON or YAML export.
7715 func (m *NamedParameter) ToRawInfo() interface{} {
7716 info := yaml.MapSlice{}
7718 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7720 // &{Name:value Type:Parameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7724 // ToRawInfo returns a description of NamedPathItem suitable for JSON or YAML export.
7725 func (m *NamedPathItem) ToRawInfo() interface{} {
7726 info := yaml.MapSlice{}
7728 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7730 // &{Name:value Type:PathItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7734 // ToRawInfo returns a description of NamedResponse suitable for JSON or YAML export.
7735 func (m *NamedResponse) ToRawInfo() interface{} {
7736 info := yaml.MapSlice{}
7738 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7740 // &{Name:value Type:Response StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7744 // ToRawInfo returns a description of NamedResponseValue suitable for JSON or YAML export.
7745 func (m *NamedResponseValue) ToRawInfo() interface{} {
7746 info := yaml.MapSlice{}
7748 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7750 // &{Name:value Type:ResponseValue StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7754 // ToRawInfo returns a description of NamedSchema suitable for JSON or YAML export.
7755 func (m *NamedSchema) ToRawInfo() interface{} {
7756 info := yaml.MapSlice{}
7758 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7760 // &{Name:value Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7764 // ToRawInfo returns a description of NamedSecurityDefinitionsItem suitable for JSON or YAML export.
7765 func (m *NamedSecurityDefinitionsItem) ToRawInfo() interface{} {
7766 info := yaml.MapSlice{}
7768 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7770 // &{Name:value Type:SecurityDefinitionsItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7774 // ToRawInfo returns a description of NamedString suitable for JSON or YAML export.
7775 func (m *NamedString) ToRawInfo() interface{} {
7776 info := yaml.MapSlice{}
7778 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7781 info = append(info, yaml.MapItem{Key: "value", Value: m.Value})
7786 // ToRawInfo returns a description of NamedStringArray suitable for JSON or YAML export.
7787 func (m *NamedStringArray) ToRawInfo() interface{} {
7788 info := yaml.MapSlice{}
7790 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
7792 // &{Name:value Type:StringArray StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
7796 // ToRawInfo returns a description of NonBodyParameter suitable for JSON or YAML export.
7797 func (m *NonBodyParameter) ToRawInfo() interface{} {
7800 // {Name:headerParameterSubSchema Type:HeaderParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7801 v0 := m.GetHeaderParameterSubSchema()
7803 return v0.ToRawInfo()
7805 // {Name:formDataParameterSubSchema Type:FormDataParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7806 v1 := m.GetFormDataParameterSubSchema()
7808 return v1.ToRawInfo()
7810 // {Name:queryParameterSubSchema Type:QueryParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7811 v2 := m.GetQueryParameterSubSchema()
7813 return v2.ToRawInfo()
7815 // {Name:pathParameterSubSchema Type:PathParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7816 v3 := m.GetPathParameterSubSchema()
7818 return v3.ToRawInfo()
7823 // ToRawInfo returns a description of Oauth2AccessCodeSecurity suitable for JSON or YAML export.
7824 func (m *Oauth2AccessCodeSecurity) ToRawInfo() interface{} {
7825 info := yaml.MapSlice{}
7827 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7830 info = append(info, yaml.MapItem{Key: "flow", Value: m.Flow})
7832 if m.Scopes != nil {
7833 info = append(info, yaml.MapItem{Key: "scopes", Value: m.Scopes.ToRawInfo()})
7835 // &{Name:scopes Type:Oauth2Scopes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7836 if m.AuthorizationUrl != "" {
7837 info = append(info, yaml.MapItem{Key: "authorizationUrl", Value: m.AuthorizationUrl})
7839 if m.TokenUrl != "" {
7840 info = append(info, yaml.MapItem{Key: "tokenUrl", Value: m.TokenUrl})
7842 if m.Description != "" {
7843 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7845 if m.VendorExtension != nil {
7846 for _, item := range m.VendorExtension {
7847 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7850 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7854 // ToRawInfo returns a description of Oauth2ApplicationSecurity suitable for JSON or YAML export.
7855 func (m *Oauth2ApplicationSecurity) ToRawInfo() interface{} {
7856 info := yaml.MapSlice{}
7858 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7861 info = append(info, yaml.MapItem{Key: "flow", Value: m.Flow})
7863 if m.Scopes != nil {
7864 info = append(info, yaml.MapItem{Key: "scopes", Value: m.Scopes.ToRawInfo()})
7866 // &{Name:scopes Type:Oauth2Scopes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7867 if m.TokenUrl != "" {
7868 info = append(info, yaml.MapItem{Key: "tokenUrl", Value: m.TokenUrl})
7870 if m.Description != "" {
7871 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7873 if m.VendorExtension != nil {
7874 for _, item := range m.VendorExtension {
7875 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7878 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7882 // ToRawInfo returns a description of Oauth2ImplicitSecurity suitable for JSON or YAML export.
7883 func (m *Oauth2ImplicitSecurity) ToRawInfo() interface{} {
7884 info := yaml.MapSlice{}
7886 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7889 info = append(info, yaml.MapItem{Key: "flow", Value: m.Flow})
7891 if m.Scopes != nil {
7892 info = append(info, yaml.MapItem{Key: "scopes", Value: m.Scopes.ToRawInfo()})
7894 // &{Name:scopes Type:Oauth2Scopes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7895 if m.AuthorizationUrl != "" {
7896 info = append(info, yaml.MapItem{Key: "authorizationUrl", Value: m.AuthorizationUrl})
7898 if m.Description != "" {
7899 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7901 if m.VendorExtension != nil {
7902 for _, item := range m.VendorExtension {
7903 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7906 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7910 // ToRawInfo returns a description of Oauth2PasswordSecurity suitable for JSON or YAML export.
7911 func (m *Oauth2PasswordSecurity) ToRawInfo() interface{} {
7912 info := yaml.MapSlice{}
7914 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
7917 info = append(info, yaml.MapItem{Key: "flow", Value: m.Flow})
7919 if m.Scopes != nil {
7920 info = append(info, yaml.MapItem{Key: "scopes", Value: m.Scopes.ToRawInfo()})
7922 // &{Name:scopes Type:Oauth2Scopes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7923 if m.TokenUrl != "" {
7924 info = append(info, yaml.MapItem{Key: "tokenUrl", Value: m.TokenUrl})
7926 if m.Description != "" {
7927 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7929 if m.VendorExtension != nil {
7930 for _, item := range m.VendorExtension {
7931 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
7934 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
7938 // ToRawInfo returns a description of Oauth2Scopes suitable for JSON or YAML export.
7939 func (m *Oauth2Scopes) ToRawInfo() interface{} {
7940 info := yaml.MapSlice{}
7941 // &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:}
7945 // ToRawInfo returns a description of Operation suitable for JSON or YAML export.
7946 func (m *Operation) ToRawInfo() interface{} {
7947 info := yaml.MapSlice{}
7948 if len(m.Tags) != 0 {
7949 info = append(info, yaml.MapItem{Key: "tags", Value: m.Tags})
7951 if m.Summary != "" {
7952 info = append(info, yaml.MapItem{Key: "summary", Value: m.Summary})
7954 if m.Description != "" {
7955 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
7957 if m.ExternalDocs != nil {
7958 info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawInfo()})
7960 // &{Name:externalDocs Type:ExternalDocs StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7961 if m.OperationId != "" {
7962 info = append(info, yaml.MapItem{Key: "operationId", Value: m.OperationId})
7964 if len(m.Produces) != 0 {
7965 info = append(info, yaml.MapItem{Key: "produces", Value: m.Produces})
7967 if len(m.Consumes) != 0 {
7968 info = append(info, yaml.MapItem{Key: "consumes", Value: m.Consumes})
7970 if len(m.Parameters) != 0 {
7971 items := make([]interface{}, 0)
7972 for _, item := range m.Parameters {
7973 items = append(items, item.ToRawInfo())
7975 info = append(info, yaml.MapItem{Key: "parameters", Value: items})
7977 // &{Name:parameters Type:ParametersItem StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:The parameters needed to send a valid API call.}
7978 if m.Responses != nil {
7979 info = append(info, yaml.MapItem{Key: "responses", Value: m.Responses.ToRawInfo()})
7981 // &{Name:responses Type:Responses StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
7982 if len(m.Schemes) != 0 {
7983 info = append(info, yaml.MapItem{Key: "schemes", Value: m.Schemes})
7985 if m.Deprecated != false {
7986 info = append(info, yaml.MapItem{Key: "deprecated", Value: m.Deprecated})
7988 if len(m.Security) != 0 {
7989 items := make([]interface{}, 0)
7990 for _, item := range m.Security {
7991 items = append(items, item.ToRawInfo())
7993 info = append(info, yaml.MapItem{Key: "security", Value: items})
7995 // &{Name:security Type:SecurityRequirement StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
7996 if m.VendorExtension != nil {
7997 for _, item := range m.VendorExtension {
7998 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8001 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8005 // ToRawInfo returns a description of Parameter suitable for JSON or YAML export.
8006 func (m *Parameter) ToRawInfo() interface{} {
8009 // {Name:bodyParameter Type:BodyParameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8010 v0 := m.GetBodyParameter()
8012 return v0.ToRawInfo()
8014 // {Name:nonBodyParameter Type:NonBodyParameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8015 v1 := m.GetNonBodyParameter()
8017 return v1.ToRawInfo()
8022 // ToRawInfo returns a description of ParameterDefinitions suitable for JSON or YAML export.
8023 func (m *ParameterDefinitions) ToRawInfo() interface{} {
8024 info := yaml.MapSlice{}
8025 if m.AdditionalProperties != nil {
8026 for _, item := range m.AdditionalProperties {
8027 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8030 // &{Name:additionalProperties Type:NamedParameter StringEnumValues:[] MapType:Parameter Repeated:true Pattern: Implicit:true Description:}
8034 // ToRawInfo returns a description of ParametersItem suitable for JSON or YAML export.
8035 func (m *ParametersItem) ToRawInfo() interface{} {
8038 // {Name:parameter Type:Parameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8039 v0 := m.GetParameter()
8041 return v0.ToRawInfo()
8043 // {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8044 v1 := m.GetJsonReference()
8046 return v1.ToRawInfo()
8051 // ToRawInfo returns a description of PathItem suitable for JSON or YAML export.
8052 func (m *PathItem) ToRawInfo() interface{} {
8053 info := yaml.MapSlice{}
8055 info = append(info, yaml.MapItem{Key: "$ref", Value: m.XRef})
8058 info = append(info, yaml.MapItem{Key: "get", Value: m.Get.ToRawInfo()})
8060 // &{Name:get Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8062 info = append(info, yaml.MapItem{Key: "put", Value: m.Put.ToRawInfo()})
8064 // &{Name:put Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8066 info = append(info, yaml.MapItem{Key: "post", Value: m.Post.ToRawInfo()})
8068 // &{Name:post Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8069 if m.Delete != nil {
8070 info = append(info, yaml.MapItem{Key: "delete", Value: m.Delete.ToRawInfo()})
8072 // &{Name:delete Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8073 if m.Options != nil {
8074 info = append(info, yaml.MapItem{Key: "options", Value: m.Options.ToRawInfo()})
8076 // &{Name:options Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8078 info = append(info, yaml.MapItem{Key: "head", Value: m.Head.ToRawInfo()})
8080 // &{Name:head Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8082 info = append(info, yaml.MapItem{Key: "patch", Value: m.Patch.ToRawInfo()})
8084 // &{Name:patch Type:Operation StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8085 if len(m.Parameters) != 0 {
8086 items := make([]interface{}, 0)
8087 for _, item := range m.Parameters {
8088 items = append(items, item.ToRawInfo())
8090 info = append(info, yaml.MapItem{Key: "parameters", Value: items})
8092 // &{Name:parameters Type:ParametersItem StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:The parameters needed to send a valid API call.}
8093 if m.VendorExtension != nil {
8094 for _, item := range m.VendorExtension {
8095 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8098 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8102 // ToRawInfo returns a description of PathParameterSubSchema suitable for JSON or YAML export.
8103 func (m *PathParameterSubSchema) ToRawInfo() interface{} {
8104 info := yaml.MapSlice{}
8105 if m.Required != false {
8106 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
8109 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
8111 if m.Description != "" {
8112 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
8115 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
8118 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
8121 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
8124 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
8126 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8127 if m.CollectionFormat != "" {
8128 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
8130 if m.Default != nil {
8131 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
8133 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8134 if m.Maximum != 0.0 {
8135 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
8137 if m.ExclusiveMaximum != false {
8138 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
8140 if m.Minimum != 0.0 {
8141 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
8143 if m.ExclusiveMinimum != false {
8144 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
8146 if m.MaxLength != 0 {
8147 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
8149 if m.MinLength != 0 {
8150 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
8152 if m.Pattern != "" {
8153 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
8155 if m.MaxItems != 0 {
8156 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
8158 if m.MinItems != 0 {
8159 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
8161 if m.UniqueItems != false {
8162 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
8164 if len(m.Enum) != 0 {
8165 items := make([]interface{}, 0)
8166 for _, item := range m.Enum {
8167 items = append(items, item.ToRawInfo())
8169 info = append(info, yaml.MapItem{Key: "enum", Value: items})
8171 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
8172 if m.MultipleOf != 0.0 {
8173 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
8175 if m.VendorExtension != nil {
8176 for _, item := range m.VendorExtension {
8177 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8180 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8184 // ToRawInfo returns a description of Paths suitable for JSON or YAML export.
8185 func (m *Paths) ToRawInfo() interface{} {
8186 info := yaml.MapSlice{}
8187 if m.VendorExtension != nil {
8188 for _, item := range m.VendorExtension {
8189 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8192 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8194 for _, item := range m.Path {
8195 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8198 // &{Name:Path Type:NamedPathItem StringEnumValues:[] MapType:PathItem Repeated:true Pattern:^/ Implicit:true Description:}
8202 // ToRawInfo returns a description of PrimitivesItems suitable for JSON or YAML export.
8203 func (m *PrimitivesItems) ToRawInfo() interface{} {
8204 info := yaml.MapSlice{}
8206 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
8209 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
8212 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
8214 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8215 if m.CollectionFormat != "" {
8216 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
8218 if m.Default != nil {
8219 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
8221 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8222 if m.Maximum != 0.0 {
8223 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
8225 if m.ExclusiveMaximum != false {
8226 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
8228 if m.Minimum != 0.0 {
8229 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
8231 if m.ExclusiveMinimum != false {
8232 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
8234 if m.MaxLength != 0 {
8235 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
8237 if m.MinLength != 0 {
8238 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
8240 if m.Pattern != "" {
8241 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
8243 if m.MaxItems != 0 {
8244 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
8246 if m.MinItems != 0 {
8247 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
8249 if m.UniqueItems != false {
8250 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
8252 if len(m.Enum) != 0 {
8253 items := make([]interface{}, 0)
8254 for _, item := range m.Enum {
8255 items = append(items, item.ToRawInfo())
8257 info = append(info, yaml.MapItem{Key: "enum", Value: items})
8259 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
8260 if m.MultipleOf != 0.0 {
8261 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
8263 if m.VendorExtension != nil {
8264 for _, item := range m.VendorExtension {
8265 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8268 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8272 // ToRawInfo returns a description of Properties suitable for JSON or YAML export.
8273 func (m *Properties) ToRawInfo() interface{} {
8274 info := yaml.MapSlice{}
8275 if m.AdditionalProperties != nil {
8276 for _, item := range m.AdditionalProperties {
8277 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8280 // &{Name:additionalProperties Type:NamedSchema StringEnumValues:[] MapType:Schema Repeated:true Pattern: Implicit:true Description:}
8284 // ToRawInfo returns a description of QueryParameterSubSchema suitable for JSON or YAML export.
8285 func (m *QueryParameterSubSchema) ToRawInfo() interface{} {
8286 info := yaml.MapSlice{}
8287 if m.Required != false {
8288 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
8291 info = append(info, yaml.MapItem{Key: "in", Value: m.In})
8293 if m.Description != "" {
8294 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
8297 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
8299 if m.AllowEmptyValue != false {
8300 info = append(info, yaml.MapItem{Key: "allowEmptyValue", Value: m.AllowEmptyValue})
8303 info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
8306 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
8309 info = append(info, yaml.MapItem{Key: "items", Value: m.Items.ToRawInfo()})
8311 // &{Name:items Type:PrimitivesItems StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8312 if m.CollectionFormat != "" {
8313 info = append(info, yaml.MapItem{Key: "collectionFormat", Value: m.CollectionFormat})
8315 if m.Default != nil {
8316 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
8318 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8319 if m.Maximum != 0.0 {
8320 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
8322 if m.ExclusiveMaximum != false {
8323 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
8325 if m.Minimum != 0.0 {
8326 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
8328 if m.ExclusiveMinimum != false {
8329 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
8331 if m.MaxLength != 0 {
8332 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
8334 if m.MinLength != 0 {
8335 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
8337 if m.Pattern != "" {
8338 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
8340 if m.MaxItems != 0 {
8341 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
8343 if m.MinItems != 0 {
8344 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
8346 if m.UniqueItems != false {
8347 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
8349 if len(m.Enum) != 0 {
8350 items := make([]interface{}, 0)
8351 for _, item := range m.Enum {
8352 items = append(items, item.ToRawInfo())
8354 info = append(info, yaml.MapItem{Key: "enum", Value: items})
8356 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
8357 if m.MultipleOf != 0.0 {
8358 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
8360 if m.VendorExtension != nil {
8361 for _, item := range m.VendorExtension {
8362 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8365 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8369 // ToRawInfo returns a description of Response suitable for JSON or YAML export.
8370 func (m *Response) ToRawInfo() interface{} {
8371 info := yaml.MapSlice{}
8372 if m.Description != "" {
8373 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
8375 if m.Schema != nil {
8376 info = append(info, yaml.MapItem{Key: "schema", Value: m.Schema.ToRawInfo()})
8378 // &{Name:schema Type:SchemaItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8379 if m.Headers != nil {
8380 info = append(info, yaml.MapItem{Key: "headers", Value: m.Headers.ToRawInfo()})
8382 // &{Name:headers Type:Headers StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8383 if m.Examples != nil {
8384 info = append(info, yaml.MapItem{Key: "examples", Value: m.Examples.ToRawInfo()})
8386 // &{Name:examples Type:Examples StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8387 if m.VendorExtension != nil {
8388 for _, item := range m.VendorExtension {
8389 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8392 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8396 // ToRawInfo returns a description of ResponseDefinitions suitable for JSON or YAML export.
8397 func (m *ResponseDefinitions) ToRawInfo() interface{} {
8398 info := yaml.MapSlice{}
8399 if m.AdditionalProperties != nil {
8400 for _, item := range m.AdditionalProperties {
8401 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8404 // &{Name:additionalProperties Type:NamedResponse StringEnumValues:[] MapType:Response Repeated:true Pattern: Implicit:true Description:}
8408 // ToRawInfo returns a description of ResponseValue suitable for JSON or YAML export.
8409 func (m *ResponseValue) ToRawInfo() interface{} {
8412 // {Name:response Type:Response StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8413 v0 := m.GetResponse()
8415 return v0.ToRawInfo()
8417 // {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8418 v1 := m.GetJsonReference()
8420 return v1.ToRawInfo()
8425 // ToRawInfo returns a description of Responses suitable for JSON or YAML export.
8426 func (m *Responses) ToRawInfo() interface{} {
8427 info := yaml.MapSlice{}
8428 if m.ResponseCode != nil {
8429 for _, item := range m.ResponseCode {
8430 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8433 // &{Name:ResponseCode Type:NamedResponseValue StringEnumValues:[] MapType:ResponseValue Repeated:true Pattern:^([0-9]{3})$|^(default)$ Implicit:true Description:}
8434 if m.VendorExtension != nil {
8435 for _, item := range m.VendorExtension {
8436 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8439 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8443 // ToRawInfo returns a description of Schema suitable for JSON or YAML export.
8444 func (m *Schema) ToRawInfo() interface{} {
8445 info := yaml.MapSlice{}
8447 info = append(info, yaml.MapItem{Key: "$ref", Value: m.XRef})
8450 info = append(info, yaml.MapItem{Key: "format", Value: m.Format})
8453 info = append(info, yaml.MapItem{Key: "title", Value: m.Title})
8455 if m.Description != "" {
8456 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
8458 if m.Default != nil {
8459 info = append(info, yaml.MapItem{Key: "default", Value: m.Default.ToRawInfo()})
8461 // &{Name:default Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8462 if m.MultipleOf != 0.0 {
8463 info = append(info, yaml.MapItem{Key: "multipleOf", Value: m.MultipleOf})
8465 if m.Maximum != 0.0 {
8466 info = append(info, yaml.MapItem{Key: "maximum", Value: m.Maximum})
8468 if m.ExclusiveMaximum != false {
8469 info = append(info, yaml.MapItem{Key: "exclusiveMaximum", Value: m.ExclusiveMaximum})
8471 if m.Minimum != 0.0 {
8472 info = append(info, yaml.MapItem{Key: "minimum", Value: m.Minimum})
8474 if m.ExclusiveMinimum != false {
8475 info = append(info, yaml.MapItem{Key: "exclusiveMinimum", Value: m.ExclusiveMinimum})
8477 if m.MaxLength != 0 {
8478 info = append(info, yaml.MapItem{Key: "maxLength", Value: m.MaxLength})
8480 if m.MinLength != 0 {
8481 info = append(info, yaml.MapItem{Key: "minLength", Value: m.MinLength})
8483 if m.Pattern != "" {
8484 info = append(info, yaml.MapItem{Key: "pattern", Value: m.Pattern})
8486 if m.MaxItems != 0 {
8487 info = append(info, yaml.MapItem{Key: "maxItems", Value: m.MaxItems})
8489 if m.MinItems != 0 {
8490 info = append(info, yaml.MapItem{Key: "minItems", Value: m.MinItems})
8492 if m.UniqueItems != false {
8493 info = append(info, yaml.MapItem{Key: "uniqueItems", Value: m.UniqueItems})
8495 if m.MaxProperties != 0 {
8496 info = append(info, yaml.MapItem{Key: "maxProperties", Value: m.MaxProperties})
8498 if m.MinProperties != 0 {
8499 info = append(info, yaml.MapItem{Key: "minProperties", Value: m.MinProperties})
8501 if len(m.Required) != 0 {
8502 info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
8504 if len(m.Enum) != 0 {
8505 items := make([]interface{}, 0)
8506 for _, item := range m.Enum {
8507 items = append(items, item.ToRawInfo())
8509 info = append(info, yaml.MapItem{Key: "enum", Value: items})
8511 // &{Name:enum Type:Any StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
8512 if m.AdditionalProperties != nil {
8513 info = append(info, yaml.MapItem{Key: "additionalProperties", Value: m.AdditionalProperties.ToRawInfo()})
8515 // &{Name:additionalProperties Type:AdditionalPropertiesItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8517 if len(m.Type.Value) == 1 {
8518 info = append(info, yaml.MapItem{Key: "type", Value: m.Type.Value[0]})
8520 info = append(info, yaml.MapItem{Key: "type", Value: m.Type.Value})
8523 // &{Name:type Type:TypeItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8525 items := make([]interface{}, 0)
8526 for _, item := range m.Items.Schema {
8527 items = append(items, item.ToRawInfo())
8529 info = append(info, yaml.MapItem{Key: "items", Value: items[0]})
8531 // &{Name:items Type:ItemsItem StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8532 if len(m.AllOf) != 0 {
8533 items := make([]interface{}, 0)
8534 for _, item := range m.AllOf {
8535 items = append(items, item.ToRawInfo())
8537 info = append(info, yaml.MapItem{Key: "allOf", Value: items})
8539 // &{Name:allOf Type:Schema StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
8540 if m.Properties != nil {
8541 info = append(info, yaml.MapItem{Key: "properties", Value: m.Properties.ToRawInfo()})
8543 // &{Name:properties Type:Properties StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8544 if m.Discriminator != "" {
8545 info = append(info, yaml.MapItem{Key: "discriminator", Value: m.Discriminator})
8547 if m.ReadOnly != false {
8548 info = append(info, yaml.MapItem{Key: "readOnly", Value: m.ReadOnly})
8551 info = append(info, yaml.MapItem{Key: "xml", Value: m.Xml.ToRawInfo()})
8553 // &{Name:xml Type:Xml StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8554 if m.ExternalDocs != nil {
8555 info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawInfo()})
8557 // &{Name:externalDocs Type:ExternalDocs StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8558 if m.Example != nil {
8559 info = append(info, yaml.MapItem{Key: "example", Value: m.Example.ToRawInfo()})
8561 // &{Name:example Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8562 if m.VendorExtension != nil {
8563 for _, item := range m.VendorExtension {
8564 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8567 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8571 // ToRawInfo returns a description of SchemaItem suitable for JSON or YAML export.
8572 func (m *SchemaItem) ToRawInfo() interface{} {
8575 // {Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8578 return v0.ToRawInfo()
8580 // {Name:fileSchema Type:FileSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8581 v1 := m.GetFileSchema()
8583 return v1.ToRawInfo()
8588 // ToRawInfo returns a description of SecurityDefinitions suitable for JSON or YAML export.
8589 func (m *SecurityDefinitions) ToRawInfo() interface{} {
8590 info := yaml.MapSlice{}
8591 if m.AdditionalProperties != nil {
8592 for _, item := range m.AdditionalProperties {
8593 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8596 // &{Name:additionalProperties Type:NamedSecurityDefinitionsItem StringEnumValues:[] MapType:SecurityDefinitionsItem Repeated:true Pattern: Implicit:true Description:}
8600 // ToRawInfo returns a description of SecurityDefinitionsItem suitable for JSON or YAML export.
8601 func (m *SecurityDefinitionsItem) ToRawInfo() interface{} {
8603 // SecurityDefinitionsItem
8604 // {Name:basicAuthenticationSecurity Type:BasicAuthenticationSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8605 v0 := m.GetBasicAuthenticationSecurity()
8607 return v0.ToRawInfo()
8609 // {Name:apiKeySecurity Type:ApiKeySecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8610 v1 := m.GetApiKeySecurity()
8612 return v1.ToRawInfo()
8614 // {Name:oauth2ImplicitSecurity Type:Oauth2ImplicitSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8615 v2 := m.GetOauth2ImplicitSecurity()
8617 return v2.ToRawInfo()
8619 // {Name:oauth2PasswordSecurity Type:Oauth2PasswordSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8620 v3 := m.GetOauth2PasswordSecurity()
8622 return v3.ToRawInfo()
8624 // {Name:oauth2ApplicationSecurity Type:Oauth2ApplicationSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8625 v4 := m.GetOauth2ApplicationSecurity()
8627 return v4.ToRawInfo()
8629 // {Name:oauth2AccessCodeSecurity Type:Oauth2AccessCodeSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8630 v5 := m.GetOauth2AccessCodeSecurity()
8632 return v5.ToRawInfo()
8637 // ToRawInfo returns a description of SecurityRequirement suitable for JSON or YAML export.
8638 func (m *SecurityRequirement) ToRawInfo() interface{} {
8639 info := yaml.MapSlice{}
8640 if m.AdditionalProperties != nil {
8641 for _, item := range m.AdditionalProperties {
8642 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8645 // &{Name:additionalProperties Type:NamedStringArray StringEnumValues:[] MapType:StringArray Repeated:true Pattern: Implicit:true Description:}
8649 // ToRawInfo returns a description of StringArray suitable for JSON or YAML export.
8650 func (m *StringArray) ToRawInfo() interface{} {
8654 // ToRawInfo returns a description of Tag suitable for JSON or YAML export.
8655 func (m *Tag) ToRawInfo() interface{} {
8656 info := yaml.MapSlice{}
8658 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
8660 if m.Description != "" {
8661 info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
8663 if m.ExternalDocs != nil {
8664 info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawInfo()})
8666 // &{Name:externalDocs Type:ExternalDocs StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
8667 if m.VendorExtension != nil {
8668 for _, item := range m.VendorExtension {
8669 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8672 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8676 // ToRawInfo returns a description of TypeItem suitable for JSON or YAML export.
8677 func (m *TypeItem) ToRawInfo() interface{} {
8678 info := yaml.MapSlice{}
8679 if len(m.Value) != 0 {
8680 info = append(info, yaml.MapItem{Key: "value", Value: m.Value})
8685 // ToRawInfo returns a description of VendorExtension suitable for JSON or YAML export.
8686 func (m *VendorExtension) ToRawInfo() interface{} {
8687 info := yaml.MapSlice{}
8688 if m.AdditionalProperties != nil {
8689 for _, item := range m.AdditionalProperties {
8690 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8693 // &{Name:additionalProperties Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern: Implicit:true Description:}
8697 // ToRawInfo returns a description of Xml suitable for JSON or YAML export.
8698 func (m *Xml) ToRawInfo() interface{} {
8699 info := yaml.MapSlice{}
8701 info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
8703 if m.Namespace != "" {
8704 info = append(info, yaml.MapItem{Key: "namespace", Value: m.Namespace})
8707 info = append(info, yaml.MapItem{Key: "prefix", Value: m.Prefix})
8709 if m.Attribute != false {
8710 info = append(info, yaml.MapItem{Key: "attribute", Value: m.Attribute})
8712 if m.Wrapped != false {
8713 info = append(info, yaml.MapItem{Key: "wrapped", Value: m.Wrapped})
8715 if m.VendorExtension != nil {
8716 for _, item := range m.VendorExtension {
8717 info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
8720 // &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
8725 pattern0 = regexp.MustCompile("^x-")
8726 pattern1 = regexp.MustCompile("^/")
8727 pattern2 = regexp.MustCompile("^([0-9]{3})$|^(default)$")