1// 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) 8729