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