1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appmesh 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/appmesh/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsRestjson1_deserializeOpCreateGatewayRoute struct { 23} 24 25func (*awsRestjson1_deserializeOpCreateGatewayRoute) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpCreateGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorCreateGatewayRoute(response, &metadata) 44 } 45 output := &CreateGatewayRouteOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsRestjson1_deserializeDocumentGatewayRouteData(&output.GatewayRoute, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 return out, metadata, &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 } 75 76 return out, metadata, err 77} 78 79func awsRestjson1_deserializeOpErrorCreateGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("BadRequestException", errorCode): 121 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 122 123 case strings.EqualFold("ConflictException", errorCode): 124 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 125 126 case strings.EqualFold("ForbiddenException", errorCode): 127 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 128 129 case strings.EqualFold("InternalServerErrorException", errorCode): 130 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 131 132 case strings.EqualFold("LimitExceededException", errorCode): 133 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 134 135 case strings.EqualFold("NotFoundException", errorCode): 136 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 137 138 case strings.EqualFold("ServiceUnavailableException", errorCode): 139 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 140 141 case strings.EqualFold("TooManyRequestsException", errorCode): 142 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 143 144 default: 145 genericError := &smithy.GenericAPIError{ 146 Code: errorCode, 147 Message: errorMessage, 148 } 149 return genericError 150 151 } 152} 153 154func awsRestjson1_deserializeOpDocumentCreateGatewayRouteOutput(v **CreateGatewayRouteOutput, value interface{}) error { 155 if v == nil { 156 return fmt.Errorf("unexpected nil of type %T", v) 157 } 158 if value == nil { 159 return nil 160 } 161 162 shape, ok := value.(map[string]interface{}) 163 if !ok { 164 return fmt.Errorf("unexpected JSON type %v", value) 165 } 166 167 var sv *CreateGatewayRouteOutput 168 if *v == nil { 169 sv = &CreateGatewayRouteOutput{} 170 } else { 171 sv = *v 172 } 173 174 for key, value := range shape { 175 switch key { 176 case "gatewayRoute": 177 if err := awsRestjson1_deserializeDocumentGatewayRouteData(&sv.GatewayRoute, value); err != nil { 178 return err 179 } 180 181 default: 182 _, _ = key, value 183 184 } 185 } 186 *v = sv 187 return nil 188} 189 190type awsRestjson1_deserializeOpCreateMesh struct { 191} 192 193func (*awsRestjson1_deserializeOpCreateMesh) ID() string { 194 return "OperationDeserializer" 195} 196 197func (m *awsRestjson1_deserializeOpCreateMesh) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 198 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 199) { 200 out, metadata, err = next.HandleDeserialize(ctx, in) 201 if err != nil { 202 return out, metadata, err 203 } 204 205 response, ok := out.RawResponse.(*smithyhttp.Response) 206 if !ok { 207 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 208 } 209 210 if response.StatusCode < 200 || response.StatusCode >= 300 { 211 return out, metadata, awsRestjson1_deserializeOpErrorCreateMesh(response, &metadata) 212 } 213 output := &CreateMeshOutput{} 214 out.Result = output 215 216 var buff [1024]byte 217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 218 219 body := io.TeeReader(response.Body, ringBuffer) 220 221 decoder := json.NewDecoder(body) 222 decoder.UseNumber() 223 var shape interface{} 224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 225 var snapshot bytes.Buffer 226 io.Copy(&snapshot, ringBuffer) 227 err = &smithy.DeserializationError{ 228 Err: fmt.Errorf("failed to decode response body, %w", err), 229 Snapshot: snapshot.Bytes(), 230 } 231 return out, metadata, err 232 } 233 234 err = awsRestjson1_deserializeDocumentMeshData(&output.Mesh, shape) 235 if err != nil { 236 var snapshot bytes.Buffer 237 io.Copy(&snapshot, ringBuffer) 238 return out, metadata, &smithy.DeserializationError{ 239 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 240 Snapshot: snapshot.Bytes(), 241 } 242 } 243 244 return out, metadata, err 245} 246 247func awsRestjson1_deserializeOpErrorCreateMesh(response *smithyhttp.Response, metadata *middleware.Metadata) error { 248 var errorBuffer bytes.Buffer 249 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 250 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 251 } 252 errorBody := bytes.NewReader(errorBuffer.Bytes()) 253 254 errorCode := "UnknownError" 255 errorMessage := errorCode 256 257 code := response.Header.Get("X-Amzn-ErrorType") 258 if len(code) != 0 { 259 errorCode = restjson.SanitizeErrorCode(code) 260 } 261 262 var buff [1024]byte 263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 264 265 body := io.TeeReader(errorBody, ringBuffer) 266 decoder := json.NewDecoder(body) 267 decoder.UseNumber() 268 code, message, err := restjson.GetErrorInfo(decoder) 269 if err != nil { 270 var snapshot bytes.Buffer 271 io.Copy(&snapshot, ringBuffer) 272 err = &smithy.DeserializationError{ 273 Err: fmt.Errorf("failed to decode response body, %w", err), 274 Snapshot: snapshot.Bytes(), 275 } 276 return err 277 } 278 279 errorBody.Seek(0, io.SeekStart) 280 if len(code) != 0 { 281 errorCode = restjson.SanitizeErrorCode(code) 282 } 283 if len(message) != 0 { 284 errorMessage = message 285 } 286 287 switch { 288 case strings.EqualFold("BadRequestException", errorCode): 289 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 290 291 case strings.EqualFold("ConflictException", errorCode): 292 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 293 294 case strings.EqualFold("ForbiddenException", errorCode): 295 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 296 297 case strings.EqualFold("InternalServerErrorException", errorCode): 298 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 299 300 case strings.EqualFold("LimitExceededException", errorCode): 301 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 302 303 case strings.EqualFold("NotFoundException", errorCode): 304 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 305 306 case strings.EqualFold("ServiceUnavailableException", errorCode): 307 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 308 309 case strings.EqualFold("TooManyRequestsException", errorCode): 310 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 311 312 default: 313 genericError := &smithy.GenericAPIError{ 314 Code: errorCode, 315 Message: errorMessage, 316 } 317 return genericError 318 319 } 320} 321 322func awsRestjson1_deserializeOpDocumentCreateMeshOutput(v **CreateMeshOutput, value interface{}) error { 323 if v == nil { 324 return fmt.Errorf("unexpected nil of type %T", v) 325 } 326 if value == nil { 327 return nil 328 } 329 330 shape, ok := value.(map[string]interface{}) 331 if !ok { 332 return fmt.Errorf("unexpected JSON type %v", value) 333 } 334 335 var sv *CreateMeshOutput 336 if *v == nil { 337 sv = &CreateMeshOutput{} 338 } else { 339 sv = *v 340 } 341 342 for key, value := range shape { 343 switch key { 344 case "mesh": 345 if err := awsRestjson1_deserializeDocumentMeshData(&sv.Mesh, value); err != nil { 346 return err 347 } 348 349 default: 350 _, _ = key, value 351 352 } 353 } 354 *v = sv 355 return nil 356} 357 358type awsRestjson1_deserializeOpCreateRoute struct { 359} 360 361func (*awsRestjson1_deserializeOpCreateRoute) ID() string { 362 return "OperationDeserializer" 363} 364 365func (m *awsRestjson1_deserializeOpCreateRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 366 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 367) { 368 out, metadata, err = next.HandleDeserialize(ctx, in) 369 if err != nil { 370 return out, metadata, err 371 } 372 373 response, ok := out.RawResponse.(*smithyhttp.Response) 374 if !ok { 375 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 376 } 377 378 if response.StatusCode < 200 || response.StatusCode >= 300 { 379 return out, metadata, awsRestjson1_deserializeOpErrorCreateRoute(response, &metadata) 380 } 381 output := &CreateRouteOutput{} 382 out.Result = output 383 384 var buff [1024]byte 385 ringBuffer := smithyio.NewRingBuffer(buff[:]) 386 387 body := io.TeeReader(response.Body, ringBuffer) 388 389 decoder := json.NewDecoder(body) 390 decoder.UseNumber() 391 var shape interface{} 392 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 393 var snapshot bytes.Buffer 394 io.Copy(&snapshot, ringBuffer) 395 err = &smithy.DeserializationError{ 396 Err: fmt.Errorf("failed to decode response body, %w", err), 397 Snapshot: snapshot.Bytes(), 398 } 399 return out, metadata, err 400 } 401 402 err = awsRestjson1_deserializeDocumentRouteData(&output.Route, shape) 403 if err != nil { 404 var snapshot bytes.Buffer 405 io.Copy(&snapshot, ringBuffer) 406 return out, metadata, &smithy.DeserializationError{ 407 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 408 Snapshot: snapshot.Bytes(), 409 } 410 } 411 412 return out, metadata, err 413} 414 415func awsRestjson1_deserializeOpErrorCreateRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 416 var errorBuffer bytes.Buffer 417 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 418 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 419 } 420 errorBody := bytes.NewReader(errorBuffer.Bytes()) 421 422 errorCode := "UnknownError" 423 errorMessage := errorCode 424 425 code := response.Header.Get("X-Amzn-ErrorType") 426 if len(code) != 0 { 427 errorCode = restjson.SanitizeErrorCode(code) 428 } 429 430 var buff [1024]byte 431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 432 433 body := io.TeeReader(errorBody, ringBuffer) 434 decoder := json.NewDecoder(body) 435 decoder.UseNumber() 436 code, message, err := restjson.GetErrorInfo(decoder) 437 if err != nil { 438 var snapshot bytes.Buffer 439 io.Copy(&snapshot, ringBuffer) 440 err = &smithy.DeserializationError{ 441 Err: fmt.Errorf("failed to decode response body, %w", err), 442 Snapshot: snapshot.Bytes(), 443 } 444 return err 445 } 446 447 errorBody.Seek(0, io.SeekStart) 448 if len(code) != 0 { 449 errorCode = restjson.SanitizeErrorCode(code) 450 } 451 if len(message) != 0 { 452 errorMessage = message 453 } 454 455 switch { 456 case strings.EqualFold("BadRequestException", errorCode): 457 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 458 459 case strings.EqualFold("ConflictException", errorCode): 460 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 461 462 case strings.EqualFold("ForbiddenException", errorCode): 463 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 464 465 case strings.EqualFold("InternalServerErrorException", errorCode): 466 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 467 468 case strings.EqualFold("LimitExceededException", errorCode): 469 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 470 471 case strings.EqualFold("NotFoundException", errorCode): 472 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 473 474 case strings.EqualFold("ServiceUnavailableException", errorCode): 475 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 476 477 case strings.EqualFold("TooManyRequestsException", errorCode): 478 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 479 480 default: 481 genericError := &smithy.GenericAPIError{ 482 Code: errorCode, 483 Message: errorMessage, 484 } 485 return genericError 486 487 } 488} 489 490func awsRestjson1_deserializeOpDocumentCreateRouteOutput(v **CreateRouteOutput, value interface{}) error { 491 if v == nil { 492 return fmt.Errorf("unexpected nil of type %T", v) 493 } 494 if value == nil { 495 return nil 496 } 497 498 shape, ok := value.(map[string]interface{}) 499 if !ok { 500 return fmt.Errorf("unexpected JSON type %v", value) 501 } 502 503 var sv *CreateRouteOutput 504 if *v == nil { 505 sv = &CreateRouteOutput{} 506 } else { 507 sv = *v 508 } 509 510 for key, value := range shape { 511 switch key { 512 case "route": 513 if err := awsRestjson1_deserializeDocumentRouteData(&sv.Route, value); err != nil { 514 return err 515 } 516 517 default: 518 _, _ = key, value 519 520 } 521 } 522 *v = sv 523 return nil 524} 525 526type awsRestjson1_deserializeOpCreateVirtualGateway struct { 527} 528 529func (*awsRestjson1_deserializeOpCreateVirtualGateway) ID() string { 530 return "OperationDeserializer" 531} 532 533func (m *awsRestjson1_deserializeOpCreateVirtualGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 534 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 535) { 536 out, metadata, err = next.HandleDeserialize(ctx, in) 537 if err != nil { 538 return out, metadata, err 539 } 540 541 response, ok := out.RawResponse.(*smithyhttp.Response) 542 if !ok { 543 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 544 } 545 546 if response.StatusCode < 200 || response.StatusCode >= 300 { 547 return out, metadata, awsRestjson1_deserializeOpErrorCreateVirtualGateway(response, &metadata) 548 } 549 output := &CreateVirtualGatewayOutput{} 550 out.Result = output 551 552 var buff [1024]byte 553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 554 555 body := io.TeeReader(response.Body, ringBuffer) 556 557 decoder := json.NewDecoder(body) 558 decoder.UseNumber() 559 var shape interface{} 560 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 561 var snapshot bytes.Buffer 562 io.Copy(&snapshot, ringBuffer) 563 err = &smithy.DeserializationError{ 564 Err: fmt.Errorf("failed to decode response body, %w", err), 565 Snapshot: snapshot.Bytes(), 566 } 567 return out, metadata, err 568 } 569 570 err = awsRestjson1_deserializeDocumentVirtualGatewayData(&output.VirtualGateway, shape) 571 if err != nil { 572 var snapshot bytes.Buffer 573 io.Copy(&snapshot, ringBuffer) 574 return out, metadata, &smithy.DeserializationError{ 575 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 576 Snapshot: snapshot.Bytes(), 577 } 578 } 579 580 return out, metadata, err 581} 582 583func awsRestjson1_deserializeOpErrorCreateVirtualGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { 584 var errorBuffer bytes.Buffer 585 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 586 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 587 } 588 errorBody := bytes.NewReader(errorBuffer.Bytes()) 589 590 errorCode := "UnknownError" 591 errorMessage := errorCode 592 593 code := response.Header.Get("X-Amzn-ErrorType") 594 if len(code) != 0 { 595 errorCode = restjson.SanitizeErrorCode(code) 596 } 597 598 var buff [1024]byte 599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 600 601 body := io.TeeReader(errorBody, ringBuffer) 602 decoder := json.NewDecoder(body) 603 decoder.UseNumber() 604 code, message, err := restjson.GetErrorInfo(decoder) 605 if err != nil { 606 var snapshot bytes.Buffer 607 io.Copy(&snapshot, ringBuffer) 608 err = &smithy.DeserializationError{ 609 Err: fmt.Errorf("failed to decode response body, %w", err), 610 Snapshot: snapshot.Bytes(), 611 } 612 return err 613 } 614 615 errorBody.Seek(0, io.SeekStart) 616 if len(code) != 0 { 617 errorCode = restjson.SanitizeErrorCode(code) 618 } 619 if len(message) != 0 { 620 errorMessage = message 621 } 622 623 switch { 624 case strings.EqualFold("BadRequestException", errorCode): 625 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 626 627 case strings.EqualFold("ConflictException", errorCode): 628 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 629 630 case strings.EqualFold("ForbiddenException", errorCode): 631 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 632 633 case strings.EqualFold("InternalServerErrorException", errorCode): 634 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 635 636 case strings.EqualFold("LimitExceededException", errorCode): 637 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 638 639 case strings.EqualFold("NotFoundException", errorCode): 640 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 641 642 case strings.EqualFold("ServiceUnavailableException", errorCode): 643 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 644 645 case strings.EqualFold("TooManyRequestsException", errorCode): 646 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 647 648 default: 649 genericError := &smithy.GenericAPIError{ 650 Code: errorCode, 651 Message: errorMessage, 652 } 653 return genericError 654 655 } 656} 657 658func awsRestjson1_deserializeOpDocumentCreateVirtualGatewayOutput(v **CreateVirtualGatewayOutput, value interface{}) error { 659 if v == nil { 660 return fmt.Errorf("unexpected nil of type %T", v) 661 } 662 if value == nil { 663 return nil 664 } 665 666 shape, ok := value.(map[string]interface{}) 667 if !ok { 668 return fmt.Errorf("unexpected JSON type %v", value) 669 } 670 671 var sv *CreateVirtualGatewayOutput 672 if *v == nil { 673 sv = &CreateVirtualGatewayOutput{} 674 } else { 675 sv = *v 676 } 677 678 for key, value := range shape { 679 switch key { 680 case "virtualGateway": 681 if err := awsRestjson1_deserializeDocumentVirtualGatewayData(&sv.VirtualGateway, value); err != nil { 682 return err 683 } 684 685 default: 686 _, _ = key, value 687 688 } 689 } 690 *v = sv 691 return nil 692} 693 694type awsRestjson1_deserializeOpCreateVirtualNode struct { 695} 696 697func (*awsRestjson1_deserializeOpCreateVirtualNode) ID() string { 698 return "OperationDeserializer" 699} 700 701func (m *awsRestjson1_deserializeOpCreateVirtualNode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 702 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 703) { 704 out, metadata, err = next.HandleDeserialize(ctx, in) 705 if err != nil { 706 return out, metadata, err 707 } 708 709 response, ok := out.RawResponse.(*smithyhttp.Response) 710 if !ok { 711 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 712 } 713 714 if response.StatusCode < 200 || response.StatusCode >= 300 { 715 return out, metadata, awsRestjson1_deserializeOpErrorCreateVirtualNode(response, &metadata) 716 } 717 output := &CreateVirtualNodeOutput{} 718 out.Result = output 719 720 var buff [1024]byte 721 ringBuffer := smithyio.NewRingBuffer(buff[:]) 722 723 body := io.TeeReader(response.Body, ringBuffer) 724 725 decoder := json.NewDecoder(body) 726 decoder.UseNumber() 727 var shape interface{} 728 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 729 var snapshot bytes.Buffer 730 io.Copy(&snapshot, ringBuffer) 731 err = &smithy.DeserializationError{ 732 Err: fmt.Errorf("failed to decode response body, %w", err), 733 Snapshot: snapshot.Bytes(), 734 } 735 return out, metadata, err 736 } 737 738 err = awsRestjson1_deserializeDocumentVirtualNodeData(&output.VirtualNode, shape) 739 if err != nil { 740 var snapshot bytes.Buffer 741 io.Copy(&snapshot, ringBuffer) 742 return out, metadata, &smithy.DeserializationError{ 743 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 744 Snapshot: snapshot.Bytes(), 745 } 746 } 747 748 return out, metadata, err 749} 750 751func awsRestjson1_deserializeOpErrorCreateVirtualNode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 752 var errorBuffer bytes.Buffer 753 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 754 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 755 } 756 errorBody := bytes.NewReader(errorBuffer.Bytes()) 757 758 errorCode := "UnknownError" 759 errorMessage := errorCode 760 761 code := response.Header.Get("X-Amzn-ErrorType") 762 if len(code) != 0 { 763 errorCode = restjson.SanitizeErrorCode(code) 764 } 765 766 var buff [1024]byte 767 ringBuffer := smithyio.NewRingBuffer(buff[:]) 768 769 body := io.TeeReader(errorBody, ringBuffer) 770 decoder := json.NewDecoder(body) 771 decoder.UseNumber() 772 code, message, err := restjson.GetErrorInfo(decoder) 773 if err != nil { 774 var snapshot bytes.Buffer 775 io.Copy(&snapshot, ringBuffer) 776 err = &smithy.DeserializationError{ 777 Err: fmt.Errorf("failed to decode response body, %w", err), 778 Snapshot: snapshot.Bytes(), 779 } 780 return err 781 } 782 783 errorBody.Seek(0, io.SeekStart) 784 if len(code) != 0 { 785 errorCode = restjson.SanitizeErrorCode(code) 786 } 787 if len(message) != 0 { 788 errorMessage = message 789 } 790 791 switch { 792 case strings.EqualFold("BadRequestException", errorCode): 793 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 794 795 case strings.EqualFold("ConflictException", errorCode): 796 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 797 798 case strings.EqualFold("ForbiddenException", errorCode): 799 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 800 801 case strings.EqualFold("InternalServerErrorException", errorCode): 802 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 803 804 case strings.EqualFold("LimitExceededException", errorCode): 805 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 806 807 case strings.EqualFold("NotFoundException", errorCode): 808 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 809 810 case strings.EqualFold("ServiceUnavailableException", errorCode): 811 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 812 813 case strings.EqualFold("TooManyRequestsException", errorCode): 814 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 815 816 default: 817 genericError := &smithy.GenericAPIError{ 818 Code: errorCode, 819 Message: errorMessage, 820 } 821 return genericError 822 823 } 824} 825 826func awsRestjson1_deserializeOpDocumentCreateVirtualNodeOutput(v **CreateVirtualNodeOutput, value interface{}) error { 827 if v == nil { 828 return fmt.Errorf("unexpected nil of type %T", v) 829 } 830 if value == nil { 831 return nil 832 } 833 834 shape, ok := value.(map[string]interface{}) 835 if !ok { 836 return fmt.Errorf("unexpected JSON type %v", value) 837 } 838 839 var sv *CreateVirtualNodeOutput 840 if *v == nil { 841 sv = &CreateVirtualNodeOutput{} 842 } else { 843 sv = *v 844 } 845 846 for key, value := range shape { 847 switch key { 848 case "virtualNode": 849 if err := awsRestjson1_deserializeDocumentVirtualNodeData(&sv.VirtualNode, value); err != nil { 850 return err 851 } 852 853 default: 854 _, _ = key, value 855 856 } 857 } 858 *v = sv 859 return nil 860} 861 862type awsRestjson1_deserializeOpCreateVirtualRouter struct { 863} 864 865func (*awsRestjson1_deserializeOpCreateVirtualRouter) ID() string { 866 return "OperationDeserializer" 867} 868 869func (m *awsRestjson1_deserializeOpCreateVirtualRouter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 870 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 871) { 872 out, metadata, err = next.HandleDeserialize(ctx, in) 873 if err != nil { 874 return out, metadata, err 875 } 876 877 response, ok := out.RawResponse.(*smithyhttp.Response) 878 if !ok { 879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 880 } 881 882 if response.StatusCode < 200 || response.StatusCode >= 300 { 883 return out, metadata, awsRestjson1_deserializeOpErrorCreateVirtualRouter(response, &metadata) 884 } 885 output := &CreateVirtualRouterOutput{} 886 out.Result = output 887 888 var buff [1024]byte 889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 890 891 body := io.TeeReader(response.Body, ringBuffer) 892 893 decoder := json.NewDecoder(body) 894 decoder.UseNumber() 895 var shape interface{} 896 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 897 var snapshot bytes.Buffer 898 io.Copy(&snapshot, ringBuffer) 899 err = &smithy.DeserializationError{ 900 Err: fmt.Errorf("failed to decode response body, %w", err), 901 Snapshot: snapshot.Bytes(), 902 } 903 return out, metadata, err 904 } 905 906 err = awsRestjson1_deserializeDocumentVirtualRouterData(&output.VirtualRouter, shape) 907 if err != nil { 908 var snapshot bytes.Buffer 909 io.Copy(&snapshot, ringBuffer) 910 return out, metadata, &smithy.DeserializationError{ 911 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 912 Snapshot: snapshot.Bytes(), 913 } 914 } 915 916 return out, metadata, err 917} 918 919func awsRestjson1_deserializeOpErrorCreateVirtualRouter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 920 var errorBuffer bytes.Buffer 921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 923 } 924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 925 926 errorCode := "UnknownError" 927 errorMessage := errorCode 928 929 code := response.Header.Get("X-Amzn-ErrorType") 930 if len(code) != 0 { 931 errorCode = restjson.SanitizeErrorCode(code) 932 } 933 934 var buff [1024]byte 935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 936 937 body := io.TeeReader(errorBody, ringBuffer) 938 decoder := json.NewDecoder(body) 939 decoder.UseNumber() 940 code, message, err := restjson.GetErrorInfo(decoder) 941 if err != nil { 942 var snapshot bytes.Buffer 943 io.Copy(&snapshot, ringBuffer) 944 err = &smithy.DeserializationError{ 945 Err: fmt.Errorf("failed to decode response body, %w", err), 946 Snapshot: snapshot.Bytes(), 947 } 948 return err 949 } 950 951 errorBody.Seek(0, io.SeekStart) 952 if len(code) != 0 { 953 errorCode = restjson.SanitizeErrorCode(code) 954 } 955 if len(message) != 0 { 956 errorMessage = message 957 } 958 959 switch { 960 case strings.EqualFold("BadRequestException", errorCode): 961 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 962 963 case strings.EqualFold("ConflictException", errorCode): 964 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 965 966 case strings.EqualFold("ForbiddenException", errorCode): 967 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 968 969 case strings.EqualFold("InternalServerErrorException", errorCode): 970 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 971 972 case strings.EqualFold("LimitExceededException", errorCode): 973 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 974 975 case strings.EqualFold("NotFoundException", errorCode): 976 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 977 978 case strings.EqualFold("ServiceUnavailableException", errorCode): 979 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 980 981 case strings.EqualFold("TooManyRequestsException", errorCode): 982 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 983 984 default: 985 genericError := &smithy.GenericAPIError{ 986 Code: errorCode, 987 Message: errorMessage, 988 } 989 return genericError 990 991 } 992} 993 994func awsRestjson1_deserializeOpDocumentCreateVirtualRouterOutput(v **CreateVirtualRouterOutput, value interface{}) error { 995 if v == nil { 996 return fmt.Errorf("unexpected nil of type %T", v) 997 } 998 if value == nil { 999 return nil 1000 } 1001 1002 shape, ok := value.(map[string]interface{}) 1003 if !ok { 1004 return fmt.Errorf("unexpected JSON type %v", value) 1005 } 1006 1007 var sv *CreateVirtualRouterOutput 1008 if *v == nil { 1009 sv = &CreateVirtualRouterOutput{} 1010 } else { 1011 sv = *v 1012 } 1013 1014 for key, value := range shape { 1015 switch key { 1016 case "virtualRouter": 1017 if err := awsRestjson1_deserializeDocumentVirtualRouterData(&sv.VirtualRouter, value); err != nil { 1018 return err 1019 } 1020 1021 default: 1022 _, _ = key, value 1023 1024 } 1025 } 1026 *v = sv 1027 return nil 1028} 1029 1030type awsRestjson1_deserializeOpCreateVirtualService struct { 1031} 1032 1033func (*awsRestjson1_deserializeOpCreateVirtualService) ID() string { 1034 return "OperationDeserializer" 1035} 1036 1037func (m *awsRestjson1_deserializeOpCreateVirtualService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1038 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1039) { 1040 out, metadata, err = next.HandleDeserialize(ctx, in) 1041 if err != nil { 1042 return out, metadata, err 1043 } 1044 1045 response, ok := out.RawResponse.(*smithyhttp.Response) 1046 if !ok { 1047 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1048 } 1049 1050 if response.StatusCode < 200 || response.StatusCode >= 300 { 1051 return out, metadata, awsRestjson1_deserializeOpErrorCreateVirtualService(response, &metadata) 1052 } 1053 output := &CreateVirtualServiceOutput{} 1054 out.Result = output 1055 1056 var buff [1024]byte 1057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1058 1059 body := io.TeeReader(response.Body, ringBuffer) 1060 1061 decoder := json.NewDecoder(body) 1062 decoder.UseNumber() 1063 var shape interface{} 1064 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1065 var snapshot bytes.Buffer 1066 io.Copy(&snapshot, ringBuffer) 1067 err = &smithy.DeserializationError{ 1068 Err: fmt.Errorf("failed to decode response body, %w", err), 1069 Snapshot: snapshot.Bytes(), 1070 } 1071 return out, metadata, err 1072 } 1073 1074 err = awsRestjson1_deserializeDocumentVirtualServiceData(&output.VirtualService, shape) 1075 if err != nil { 1076 var snapshot bytes.Buffer 1077 io.Copy(&snapshot, ringBuffer) 1078 return out, metadata, &smithy.DeserializationError{ 1079 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1080 Snapshot: snapshot.Bytes(), 1081 } 1082 } 1083 1084 return out, metadata, err 1085} 1086 1087func awsRestjson1_deserializeOpErrorCreateVirtualService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1088 var errorBuffer bytes.Buffer 1089 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1090 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1091 } 1092 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1093 1094 errorCode := "UnknownError" 1095 errorMessage := errorCode 1096 1097 code := response.Header.Get("X-Amzn-ErrorType") 1098 if len(code) != 0 { 1099 errorCode = restjson.SanitizeErrorCode(code) 1100 } 1101 1102 var buff [1024]byte 1103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1104 1105 body := io.TeeReader(errorBody, ringBuffer) 1106 decoder := json.NewDecoder(body) 1107 decoder.UseNumber() 1108 code, message, err := restjson.GetErrorInfo(decoder) 1109 if err != nil { 1110 var snapshot bytes.Buffer 1111 io.Copy(&snapshot, ringBuffer) 1112 err = &smithy.DeserializationError{ 1113 Err: fmt.Errorf("failed to decode response body, %w", err), 1114 Snapshot: snapshot.Bytes(), 1115 } 1116 return err 1117 } 1118 1119 errorBody.Seek(0, io.SeekStart) 1120 if len(code) != 0 { 1121 errorCode = restjson.SanitizeErrorCode(code) 1122 } 1123 if len(message) != 0 { 1124 errorMessage = message 1125 } 1126 1127 switch { 1128 case strings.EqualFold("BadRequestException", errorCode): 1129 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1130 1131 case strings.EqualFold("ConflictException", errorCode): 1132 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1133 1134 case strings.EqualFold("ForbiddenException", errorCode): 1135 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1136 1137 case strings.EqualFold("InternalServerErrorException", errorCode): 1138 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1139 1140 case strings.EqualFold("LimitExceededException", errorCode): 1141 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1142 1143 case strings.EqualFold("NotFoundException", errorCode): 1144 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1145 1146 case strings.EqualFold("ServiceUnavailableException", errorCode): 1147 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1148 1149 case strings.EqualFold("TooManyRequestsException", errorCode): 1150 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1151 1152 default: 1153 genericError := &smithy.GenericAPIError{ 1154 Code: errorCode, 1155 Message: errorMessage, 1156 } 1157 return genericError 1158 1159 } 1160} 1161 1162func awsRestjson1_deserializeOpDocumentCreateVirtualServiceOutput(v **CreateVirtualServiceOutput, value interface{}) error { 1163 if v == nil { 1164 return fmt.Errorf("unexpected nil of type %T", v) 1165 } 1166 if value == nil { 1167 return nil 1168 } 1169 1170 shape, ok := value.(map[string]interface{}) 1171 if !ok { 1172 return fmt.Errorf("unexpected JSON type %v", value) 1173 } 1174 1175 var sv *CreateVirtualServiceOutput 1176 if *v == nil { 1177 sv = &CreateVirtualServiceOutput{} 1178 } else { 1179 sv = *v 1180 } 1181 1182 for key, value := range shape { 1183 switch key { 1184 case "virtualService": 1185 if err := awsRestjson1_deserializeDocumentVirtualServiceData(&sv.VirtualService, value); err != nil { 1186 return err 1187 } 1188 1189 default: 1190 _, _ = key, value 1191 1192 } 1193 } 1194 *v = sv 1195 return nil 1196} 1197 1198type awsRestjson1_deserializeOpDeleteGatewayRoute struct { 1199} 1200 1201func (*awsRestjson1_deserializeOpDeleteGatewayRoute) ID() string { 1202 return "OperationDeserializer" 1203} 1204 1205func (m *awsRestjson1_deserializeOpDeleteGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1207) { 1208 out, metadata, err = next.HandleDeserialize(ctx, in) 1209 if err != nil { 1210 return out, metadata, err 1211 } 1212 1213 response, ok := out.RawResponse.(*smithyhttp.Response) 1214 if !ok { 1215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1216 } 1217 1218 if response.StatusCode < 200 || response.StatusCode >= 300 { 1219 return out, metadata, awsRestjson1_deserializeOpErrorDeleteGatewayRoute(response, &metadata) 1220 } 1221 output := &DeleteGatewayRouteOutput{} 1222 out.Result = output 1223 1224 var buff [1024]byte 1225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1226 1227 body := io.TeeReader(response.Body, ringBuffer) 1228 1229 decoder := json.NewDecoder(body) 1230 decoder.UseNumber() 1231 var shape interface{} 1232 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1233 var snapshot bytes.Buffer 1234 io.Copy(&snapshot, ringBuffer) 1235 err = &smithy.DeserializationError{ 1236 Err: fmt.Errorf("failed to decode response body, %w", err), 1237 Snapshot: snapshot.Bytes(), 1238 } 1239 return out, metadata, err 1240 } 1241 1242 err = awsRestjson1_deserializeDocumentGatewayRouteData(&output.GatewayRoute, shape) 1243 if err != nil { 1244 var snapshot bytes.Buffer 1245 io.Copy(&snapshot, ringBuffer) 1246 return out, metadata, &smithy.DeserializationError{ 1247 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1248 Snapshot: snapshot.Bytes(), 1249 } 1250 } 1251 1252 return out, metadata, err 1253} 1254 1255func awsRestjson1_deserializeOpErrorDeleteGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1256 var errorBuffer bytes.Buffer 1257 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1258 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1259 } 1260 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1261 1262 errorCode := "UnknownError" 1263 errorMessage := errorCode 1264 1265 code := response.Header.Get("X-Amzn-ErrorType") 1266 if len(code) != 0 { 1267 errorCode = restjson.SanitizeErrorCode(code) 1268 } 1269 1270 var buff [1024]byte 1271 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1272 1273 body := io.TeeReader(errorBody, ringBuffer) 1274 decoder := json.NewDecoder(body) 1275 decoder.UseNumber() 1276 code, message, err := restjson.GetErrorInfo(decoder) 1277 if err != nil { 1278 var snapshot bytes.Buffer 1279 io.Copy(&snapshot, ringBuffer) 1280 err = &smithy.DeserializationError{ 1281 Err: fmt.Errorf("failed to decode response body, %w", err), 1282 Snapshot: snapshot.Bytes(), 1283 } 1284 return err 1285 } 1286 1287 errorBody.Seek(0, io.SeekStart) 1288 if len(code) != 0 { 1289 errorCode = restjson.SanitizeErrorCode(code) 1290 } 1291 if len(message) != 0 { 1292 errorMessage = message 1293 } 1294 1295 switch { 1296 case strings.EqualFold("BadRequestException", errorCode): 1297 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1298 1299 case strings.EqualFold("ForbiddenException", errorCode): 1300 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1301 1302 case strings.EqualFold("InternalServerErrorException", errorCode): 1303 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1304 1305 case strings.EqualFold("NotFoundException", errorCode): 1306 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1307 1308 case strings.EqualFold("ResourceInUseException", errorCode): 1309 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1310 1311 case strings.EqualFold("ServiceUnavailableException", errorCode): 1312 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1313 1314 case strings.EqualFold("TooManyRequestsException", errorCode): 1315 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1316 1317 default: 1318 genericError := &smithy.GenericAPIError{ 1319 Code: errorCode, 1320 Message: errorMessage, 1321 } 1322 return genericError 1323 1324 } 1325} 1326 1327func awsRestjson1_deserializeOpDocumentDeleteGatewayRouteOutput(v **DeleteGatewayRouteOutput, value interface{}) error { 1328 if v == nil { 1329 return fmt.Errorf("unexpected nil of type %T", v) 1330 } 1331 if value == nil { 1332 return nil 1333 } 1334 1335 shape, ok := value.(map[string]interface{}) 1336 if !ok { 1337 return fmt.Errorf("unexpected JSON type %v", value) 1338 } 1339 1340 var sv *DeleteGatewayRouteOutput 1341 if *v == nil { 1342 sv = &DeleteGatewayRouteOutput{} 1343 } else { 1344 sv = *v 1345 } 1346 1347 for key, value := range shape { 1348 switch key { 1349 case "gatewayRoute": 1350 if err := awsRestjson1_deserializeDocumentGatewayRouteData(&sv.GatewayRoute, value); err != nil { 1351 return err 1352 } 1353 1354 default: 1355 _, _ = key, value 1356 1357 } 1358 } 1359 *v = sv 1360 return nil 1361} 1362 1363type awsRestjson1_deserializeOpDeleteMesh struct { 1364} 1365 1366func (*awsRestjson1_deserializeOpDeleteMesh) ID() string { 1367 return "OperationDeserializer" 1368} 1369 1370func (m *awsRestjson1_deserializeOpDeleteMesh) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1371 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1372) { 1373 out, metadata, err = next.HandleDeserialize(ctx, in) 1374 if err != nil { 1375 return out, metadata, err 1376 } 1377 1378 response, ok := out.RawResponse.(*smithyhttp.Response) 1379 if !ok { 1380 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1381 } 1382 1383 if response.StatusCode < 200 || response.StatusCode >= 300 { 1384 return out, metadata, awsRestjson1_deserializeOpErrorDeleteMesh(response, &metadata) 1385 } 1386 output := &DeleteMeshOutput{} 1387 out.Result = output 1388 1389 var buff [1024]byte 1390 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1391 1392 body := io.TeeReader(response.Body, ringBuffer) 1393 1394 decoder := json.NewDecoder(body) 1395 decoder.UseNumber() 1396 var shape interface{} 1397 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1398 var snapshot bytes.Buffer 1399 io.Copy(&snapshot, ringBuffer) 1400 err = &smithy.DeserializationError{ 1401 Err: fmt.Errorf("failed to decode response body, %w", err), 1402 Snapshot: snapshot.Bytes(), 1403 } 1404 return out, metadata, err 1405 } 1406 1407 err = awsRestjson1_deserializeDocumentMeshData(&output.Mesh, shape) 1408 if err != nil { 1409 var snapshot bytes.Buffer 1410 io.Copy(&snapshot, ringBuffer) 1411 return out, metadata, &smithy.DeserializationError{ 1412 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1413 Snapshot: snapshot.Bytes(), 1414 } 1415 } 1416 1417 return out, metadata, err 1418} 1419 1420func awsRestjson1_deserializeOpErrorDeleteMesh(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1421 var errorBuffer bytes.Buffer 1422 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1423 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1424 } 1425 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1426 1427 errorCode := "UnknownError" 1428 errorMessage := errorCode 1429 1430 code := response.Header.Get("X-Amzn-ErrorType") 1431 if len(code) != 0 { 1432 errorCode = restjson.SanitizeErrorCode(code) 1433 } 1434 1435 var buff [1024]byte 1436 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1437 1438 body := io.TeeReader(errorBody, ringBuffer) 1439 decoder := json.NewDecoder(body) 1440 decoder.UseNumber() 1441 code, message, err := restjson.GetErrorInfo(decoder) 1442 if err != nil { 1443 var snapshot bytes.Buffer 1444 io.Copy(&snapshot, ringBuffer) 1445 err = &smithy.DeserializationError{ 1446 Err: fmt.Errorf("failed to decode response body, %w", err), 1447 Snapshot: snapshot.Bytes(), 1448 } 1449 return err 1450 } 1451 1452 errorBody.Seek(0, io.SeekStart) 1453 if len(code) != 0 { 1454 errorCode = restjson.SanitizeErrorCode(code) 1455 } 1456 if len(message) != 0 { 1457 errorMessage = message 1458 } 1459 1460 switch { 1461 case strings.EqualFold("BadRequestException", errorCode): 1462 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1463 1464 case strings.EqualFold("ForbiddenException", errorCode): 1465 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1466 1467 case strings.EqualFold("InternalServerErrorException", errorCode): 1468 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1469 1470 case strings.EqualFold("NotFoundException", errorCode): 1471 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1472 1473 case strings.EqualFold("ResourceInUseException", errorCode): 1474 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1475 1476 case strings.EqualFold("ServiceUnavailableException", errorCode): 1477 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1478 1479 case strings.EqualFold("TooManyRequestsException", errorCode): 1480 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1481 1482 default: 1483 genericError := &smithy.GenericAPIError{ 1484 Code: errorCode, 1485 Message: errorMessage, 1486 } 1487 return genericError 1488 1489 } 1490} 1491 1492func awsRestjson1_deserializeOpDocumentDeleteMeshOutput(v **DeleteMeshOutput, value interface{}) error { 1493 if v == nil { 1494 return fmt.Errorf("unexpected nil of type %T", v) 1495 } 1496 if value == nil { 1497 return nil 1498 } 1499 1500 shape, ok := value.(map[string]interface{}) 1501 if !ok { 1502 return fmt.Errorf("unexpected JSON type %v", value) 1503 } 1504 1505 var sv *DeleteMeshOutput 1506 if *v == nil { 1507 sv = &DeleteMeshOutput{} 1508 } else { 1509 sv = *v 1510 } 1511 1512 for key, value := range shape { 1513 switch key { 1514 case "mesh": 1515 if err := awsRestjson1_deserializeDocumentMeshData(&sv.Mesh, value); err != nil { 1516 return err 1517 } 1518 1519 default: 1520 _, _ = key, value 1521 1522 } 1523 } 1524 *v = sv 1525 return nil 1526} 1527 1528type awsRestjson1_deserializeOpDeleteRoute struct { 1529} 1530 1531func (*awsRestjson1_deserializeOpDeleteRoute) ID() string { 1532 return "OperationDeserializer" 1533} 1534 1535func (m *awsRestjson1_deserializeOpDeleteRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1536 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1537) { 1538 out, metadata, err = next.HandleDeserialize(ctx, in) 1539 if err != nil { 1540 return out, metadata, err 1541 } 1542 1543 response, ok := out.RawResponse.(*smithyhttp.Response) 1544 if !ok { 1545 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1546 } 1547 1548 if response.StatusCode < 200 || response.StatusCode >= 300 { 1549 return out, metadata, awsRestjson1_deserializeOpErrorDeleteRoute(response, &metadata) 1550 } 1551 output := &DeleteRouteOutput{} 1552 out.Result = output 1553 1554 var buff [1024]byte 1555 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1556 1557 body := io.TeeReader(response.Body, ringBuffer) 1558 1559 decoder := json.NewDecoder(body) 1560 decoder.UseNumber() 1561 var shape interface{} 1562 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1563 var snapshot bytes.Buffer 1564 io.Copy(&snapshot, ringBuffer) 1565 err = &smithy.DeserializationError{ 1566 Err: fmt.Errorf("failed to decode response body, %w", err), 1567 Snapshot: snapshot.Bytes(), 1568 } 1569 return out, metadata, err 1570 } 1571 1572 err = awsRestjson1_deserializeDocumentRouteData(&output.Route, shape) 1573 if err != nil { 1574 var snapshot bytes.Buffer 1575 io.Copy(&snapshot, ringBuffer) 1576 return out, metadata, &smithy.DeserializationError{ 1577 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1578 Snapshot: snapshot.Bytes(), 1579 } 1580 } 1581 1582 return out, metadata, err 1583} 1584 1585func awsRestjson1_deserializeOpErrorDeleteRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1586 var errorBuffer bytes.Buffer 1587 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1588 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1589 } 1590 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1591 1592 errorCode := "UnknownError" 1593 errorMessage := errorCode 1594 1595 code := response.Header.Get("X-Amzn-ErrorType") 1596 if len(code) != 0 { 1597 errorCode = restjson.SanitizeErrorCode(code) 1598 } 1599 1600 var buff [1024]byte 1601 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1602 1603 body := io.TeeReader(errorBody, ringBuffer) 1604 decoder := json.NewDecoder(body) 1605 decoder.UseNumber() 1606 code, message, err := restjson.GetErrorInfo(decoder) 1607 if err != nil { 1608 var snapshot bytes.Buffer 1609 io.Copy(&snapshot, ringBuffer) 1610 err = &smithy.DeserializationError{ 1611 Err: fmt.Errorf("failed to decode response body, %w", err), 1612 Snapshot: snapshot.Bytes(), 1613 } 1614 return err 1615 } 1616 1617 errorBody.Seek(0, io.SeekStart) 1618 if len(code) != 0 { 1619 errorCode = restjson.SanitizeErrorCode(code) 1620 } 1621 if len(message) != 0 { 1622 errorMessage = message 1623 } 1624 1625 switch { 1626 case strings.EqualFold("BadRequestException", errorCode): 1627 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1628 1629 case strings.EqualFold("ForbiddenException", errorCode): 1630 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1631 1632 case strings.EqualFold("InternalServerErrorException", errorCode): 1633 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1634 1635 case strings.EqualFold("NotFoundException", errorCode): 1636 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1637 1638 case strings.EqualFold("ResourceInUseException", errorCode): 1639 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1640 1641 case strings.EqualFold("ServiceUnavailableException", errorCode): 1642 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1643 1644 case strings.EqualFold("TooManyRequestsException", errorCode): 1645 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1646 1647 default: 1648 genericError := &smithy.GenericAPIError{ 1649 Code: errorCode, 1650 Message: errorMessage, 1651 } 1652 return genericError 1653 1654 } 1655} 1656 1657func awsRestjson1_deserializeOpDocumentDeleteRouteOutput(v **DeleteRouteOutput, value interface{}) error { 1658 if v == nil { 1659 return fmt.Errorf("unexpected nil of type %T", v) 1660 } 1661 if value == nil { 1662 return nil 1663 } 1664 1665 shape, ok := value.(map[string]interface{}) 1666 if !ok { 1667 return fmt.Errorf("unexpected JSON type %v", value) 1668 } 1669 1670 var sv *DeleteRouteOutput 1671 if *v == nil { 1672 sv = &DeleteRouteOutput{} 1673 } else { 1674 sv = *v 1675 } 1676 1677 for key, value := range shape { 1678 switch key { 1679 case "route": 1680 if err := awsRestjson1_deserializeDocumentRouteData(&sv.Route, value); err != nil { 1681 return err 1682 } 1683 1684 default: 1685 _, _ = key, value 1686 1687 } 1688 } 1689 *v = sv 1690 return nil 1691} 1692 1693type awsRestjson1_deserializeOpDeleteVirtualGateway struct { 1694} 1695 1696func (*awsRestjson1_deserializeOpDeleteVirtualGateway) ID() string { 1697 return "OperationDeserializer" 1698} 1699 1700func (m *awsRestjson1_deserializeOpDeleteVirtualGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1701 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1702) { 1703 out, metadata, err = next.HandleDeserialize(ctx, in) 1704 if err != nil { 1705 return out, metadata, err 1706 } 1707 1708 response, ok := out.RawResponse.(*smithyhttp.Response) 1709 if !ok { 1710 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1711 } 1712 1713 if response.StatusCode < 200 || response.StatusCode >= 300 { 1714 return out, metadata, awsRestjson1_deserializeOpErrorDeleteVirtualGateway(response, &metadata) 1715 } 1716 output := &DeleteVirtualGatewayOutput{} 1717 out.Result = output 1718 1719 var buff [1024]byte 1720 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1721 1722 body := io.TeeReader(response.Body, ringBuffer) 1723 1724 decoder := json.NewDecoder(body) 1725 decoder.UseNumber() 1726 var shape interface{} 1727 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1728 var snapshot bytes.Buffer 1729 io.Copy(&snapshot, ringBuffer) 1730 err = &smithy.DeserializationError{ 1731 Err: fmt.Errorf("failed to decode response body, %w", err), 1732 Snapshot: snapshot.Bytes(), 1733 } 1734 return out, metadata, err 1735 } 1736 1737 err = awsRestjson1_deserializeDocumentVirtualGatewayData(&output.VirtualGateway, shape) 1738 if err != nil { 1739 var snapshot bytes.Buffer 1740 io.Copy(&snapshot, ringBuffer) 1741 return out, metadata, &smithy.DeserializationError{ 1742 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1743 Snapshot: snapshot.Bytes(), 1744 } 1745 } 1746 1747 return out, metadata, err 1748} 1749 1750func awsRestjson1_deserializeOpErrorDeleteVirtualGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1751 var errorBuffer bytes.Buffer 1752 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1753 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1754 } 1755 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1756 1757 errorCode := "UnknownError" 1758 errorMessage := errorCode 1759 1760 code := response.Header.Get("X-Amzn-ErrorType") 1761 if len(code) != 0 { 1762 errorCode = restjson.SanitizeErrorCode(code) 1763 } 1764 1765 var buff [1024]byte 1766 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1767 1768 body := io.TeeReader(errorBody, ringBuffer) 1769 decoder := json.NewDecoder(body) 1770 decoder.UseNumber() 1771 code, message, err := restjson.GetErrorInfo(decoder) 1772 if err != nil { 1773 var snapshot bytes.Buffer 1774 io.Copy(&snapshot, ringBuffer) 1775 err = &smithy.DeserializationError{ 1776 Err: fmt.Errorf("failed to decode response body, %w", err), 1777 Snapshot: snapshot.Bytes(), 1778 } 1779 return err 1780 } 1781 1782 errorBody.Seek(0, io.SeekStart) 1783 if len(code) != 0 { 1784 errorCode = restjson.SanitizeErrorCode(code) 1785 } 1786 if len(message) != 0 { 1787 errorMessage = message 1788 } 1789 1790 switch { 1791 case strings.EqualFold("BadRequestException", errorCode): 1792 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1793 1794 case strings.EqualFold("ForbiddenException", errorCode): 1795 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1796 1797 case strings.EqualFold("InternalServerErrorException", errorCode): 1798 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1799 1800 case strings.EqualFold("NotFoundException", errorCode): 1801 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1802 1803 case strings.EqualFold("ResourceInUseException", errorCode): 1804 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1805 1806 case strings.EqualFold("ServiceUnavailableException", errorCode): 1807 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1808 1809 case strings.EqualFold("TooManyRequestsException", errorCode): 1810 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1811 1812 default: 1813 genericError := &smithy.GenericAPIError{ 1814 Code: errorCode, 1815 Message: errorMessage, 1816 } 1817 return genericError 1818 1819 } 1820} 1821 1822func awsRestjson1_deserializeOpDocumentDeleteVirtualGatewayOutput(v **DeleteVirtualGatewayOutput, value interface{}) error { 1823 if v == nil { 1824 return fmt.Errorf("unexpected nil of type %T", v) 1825 } 1826 if value == nil { 1827 return nil 1828 } 1829 1830 shape, ok := value.(map[string]interface{}) 1831 if !ok { 1832 return fmt.Errorf("unexpected JSON type %v", value) 1833 } 1834 1835 var sv *DeleteVirtualGatewayOutput 1836 if *v == nil { 1837 sv = &DeleteVirtualGatewayOutput{} 1838 } else { 1839 sv = *v 1840 } 1841 1842 for key, value := range shape { 1843 switch key { 1844 case "virtualGateway": 1845 if err := awsRestjson1_deserializeDocumentVirtualGatewayData(&sv.VirtualGateway, value); err != nil { 1846 return err 1847 } 1848 1849 default: 1850 _, _ = key, value 1851 1852 } 1853 } 1854 *v = sv 1855 return nil 1856} 1857 1858type awsRestjson1_deserializeOpDeleteVirtualNode struct { 1859} 1860 1861func (*awsRestjson1_deserializeOpDeleteVirtualNode) ID() string { 1862 return "OperationDeserializer" 1863} 1864 1865func (m *awsRestjson1_deserializeOpDeleteVirtualNode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1866 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1867) { 1868 out, metadata, err = next.HandleDeserialize(ctx, in) 1869 if err != nil { 1870 return out, metadata, err 1871 } 1872 1873 response, ok := out.RawResponse.(*smithyhttp.Response) 1874 if !ok { 1875 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1876 } 1877 1878 if response.StatusCode < 200 || response.StatusCode >= 300 { 1879 return out, metadata, awsRestjson1_deserializeOpErrorDeleteVirtualNode(response, &metadata) 1880 } 1881 output := &DeleteVirtualNodeOutput{} 1882 out.Result = output 1883 1884 var buff [1024]byte 1885 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1886 1887 body := io.TeeReader(response.Body, ringBuffer) 1888 1889 decoder := json.NewDecoder(body) 1890 decoder.UseNumber() 1891 var shape interface{} 1892 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1893 var snapshot bytes.Buffer 1894 io.Copy(&snapshot, ringBuffer) 1895 err = &smithy.DeserializationError{ 1896 Err: fmt.Errorf("failed to decode response body, %w", err), 1897 Snapshot: snapshot.Bytes(), 1898 } 1899 return out, metadata, err 1900 } 1901 1902 err = awsRestjson1_deserializeDocumentVirtualNodeData(&output.VirtualNode, shape) 1903 if err != nil { 1904 var snapshot bytes.Buffer 1905 io.Copy(&snapshot, ringBuffer) 1906 return out, metadata, &smithy.DeserializationError{ 1907 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1908 Snapshot: snapshot.Bytes(), 1909 } 1910 } 1911 1912 return out, metadata, err 1913} 1914 1915func awsRestjson1_deserializeOpErrorDeleteVirtualNode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1916 var errorBuffer bytes.Buffer 1917 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1918 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1919 } 1920 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1921 1922 errorCode := "UnknownError" 1923 errorMessage := errorCode 1924 1925 code := response.Header.Get("X-Amzn-ErrorType") 1926 if len(code) != 0 { 1927 errorCode = restjson.SanitizeErrorCode(code) 1928 } 1929 1930 var buff [1024]byte 1931 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1932 1933 body := io.TeeReader(errorBody, ringBuffer) 1934 decoder := json.NewDecoder(body) 1935 decoder.UseNumber() 1936 code, message, err := restjson.GetErrorInfo(decoder) 1937 if err != nil { 1938 var snapshot bytes.Buffer 1939 io.Copy(&snapshot, ringBuffer) 1940 err = &smithy.DeserializationError{ 1941 Err: fmt.Errorf("failed to decode response body, %w", err), 1942 Snapshot: snapshot.Bytes(), 1943 } 1944 return err 1945 } 1946 1947 errorBody.Seek(0, io.SeekStart) 1948 if len(code) != 0 { 1949 errorCode = restjson.SanitizeErrorCode(code) 1950 } 1951 if len(message) != 0 { 1952 errorMessage = message 1953 } 1954 1955 switch { 1956 case strings.EqualFold("BadRequestException", errorCode): 1957 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1958 1959 case strings.EqualFold("ForbiddenException", errorCode): 1960 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 1961 1962 case strings.EqualFold("InternalServerErrorException", errorCode): 1963 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1964 1965 case strings.EqualFold("NotFoundException", errorCode): 1966 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 1967 1968 case strings.EqualFold("ResourceInUseException", errorCode): 1969 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 1970 1971 case strings.EqualFold("ServiceUnavailableException", errorCode): 1972 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 1973 1974 case strings.EqualFold("TooManyRequestsException", errorCode): 1975 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 1976 1977 default: 1978 genericError := &smithy.GenericAPIError{ 1979 Code: errorCode, 1980 Message: errorMessage, 1981 } 1982 return genericError 1983 1984 } 1985} 1986 1987func awsRestjson1_deserializeOpDocumentDeleteVirtualNodeOutput(v **DeleteVirtualNodeOutput, value interface{}) error { 1988 if v == nil { 1989 return fmt.Errorf("unexpected nil of type %T", v) 1990 } 1991 if value == nil { 1992 return nil 1993 } 1994 1995 shape, ok := value.(map[string]interface{}) 1996 if !ok { 1997 return fmt.Errorf("unexpected JSON type %v", value) 1998 } 1999 2000 var sv *DeleteVirtualNodeOutput 2001 if *v == nil { 2002 sv = &DeleteVirtualNodeOutput{} 2003 } else { 2004 sv = *v 2005 } 2006 2007 for key, value := range shape { 2008 switch key { 2009 case "virtualNode": 2010 if err := awsRestjson1_deserializeDocumentVirtualNodeData(&sv.VirtualNode, value); err != nil { 2011 return err 2012 } 2013 2014 default: 2015 _, _ = key, value 2016 2017 } 2018 } 2019 *v = sv 2020 return nil 2021} 2022 2023type awsRestjson1_deserializeOpDeleteVirtualRouter struct { 2024} 2025 2026func (*awsRestjson1_deserializeOpDeleteVirtualRouter) ID() string { 2027 return "OperationDeserializer" 2028} 2029 2030func (m *awsRestjson1_deserializeOpDeleteVirtualRouter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2031 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2032) { 2033 out, metadata, err = next.HandleDeserialize(ctx, in) 2034 if err != nil { 2035 return out, metadata, err 2036 } 2037 2038 response, ok := out.RawResponse.(*smithyhttp.Response) 2039 if !ok { 2040 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2041 } 2042 2043 if response.StatusCode < 200 || response.StatusCode >= 300 { 2044 return out, metadata, awsRestjson1_deserializeOpErrorDeleteVirtualRouter(response, &metadata) 2045 } 2046 output := &DeleteVirtualRouterOutput{} 2047 out.Result = output 2048 2049 var buff [1024]byte 2050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2051 2052 body := io.TeeReader(response.Body, ringBuffer) 2053 2054 decoder := json.NewDecoder(body) 2055 decoder.UseNumber() 2056 var shape interface{} 2057 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2058 var snapshot bytes.Buffer 2059 io.Copy(&snapshot, ringBuffer) 2060 err = &smithy.DeserializationError{ 2061 Err: fmt.Errorf("failed to decode response body, %w", err), 2062 Snapshot: snapshot.Bytes(), 2063 } 2064 return out, metadata, err 2065 } 2066 2067 err = awsRestjson1_deserializeDocumentVirtualRouterData(&output.VirtualRouter, shape) 2068 if err != nil { 2069 var snapshot bytes.Buffer 2070 io.Copy(&snapshot, ringBuffer) 2071 return out, metadata, &smithy.DeserializationError{ 2072 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2073 Snapshot: snapshot.Bytes(), 2074 } 2075 } 2076 2077 return out, metadata, err 2078} 2079 2080func awsRestjson1_deserializeOpErrorDeleteVirtualRouter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2081 var errorBuffer bytes.Buffer 2082 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2083 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2084 } 2085 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2086 2087 errorCode := "UnknownError" 2088 errorMessage := errorCode 2089 2090 code := response.Header.Get("X-Amzn-ErrorType") 2091 if len(code) != 0 { 2092 errorCode = restjson.SanitizeErrorCode(code) 2093 } 2094 2095 var buff [1024]byte 2096 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2097 2098 body := io.TeeReader(errorBody, ringBuffer) 2099 decoder := json.NewDecoder(body) 2100 decoder.UseNumber() 2101 code, message, err := restjson.GetErrorInfo(decoder) 2102 if err != nil { 2103 var snapshot bytes.Buffer 2104 io.Copy(&snapshot, ringBuffer) 2105 err = &smithy.DeserializationError{ 2106 Err: fmt.Errorf("failed to decode response body, %w", err), 2107 Snapshot: snapshot.Bytes(), 2108 } 2109 return err 2110 } 2111 2112 errorBody.Seek(0, io.SeekStart) 2113 if len(code) != 0 { 2114 errorCode = restjson.SanitizeErrorCode(code) 2115 } 2116 if len(message) != 0 { 2117 errorMessage = message 2118 } 2119 2120 switch { 2121 case strings.EqualFold("BadRequestException", errorCode): 2122 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2123 2124 case strings.EqualFold("ForbiddenException", errorCode): 2125 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2126 2127 case strings.EqualFold("InternalServerErrorException", errorCode): 2128 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2129 2130 case strings.EqualFold("NotFoundException", errorCode): 2131 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2132 2133 case strings.EqualFold("ResourceInUseException", errorCode): 2134 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 2135 2136 case strings.EqualFold("ServiceUnavailableException", errorCode): 2137 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2138 2139 case strings.EqualFold("TooManyRequestsException", errorCode): 2140 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2141 2142 default: 2143 genericError := &smithy.GenericAPIError{ 2144 Code: errorCode, 2145 Message: errorMessage, 2146 } 2147 return genericError 2148 2149 } 2150} 2151 2152func awsRestjson1_deserializeOpDocumentDeleteVirtualRouterOutput(v **DeleteVirtualRouterOutput, value interface{}) error { 2153 if v == nil { 2154 return fmt.Errorf("unexpected nil of type %T", v) 2155 } 2156 if value == nil { 2157 return nil 2158 } 2159 2160 shape, ok := value.(map[string]interface{}) 2161 if !ok { 2162 return fmt.Errorf("unexpected JSON type %v", value) 2163 } 2164 2165 var sv *DeleteVirtualRouterOutput 2166 if *v == nil { 2167 sv = &DeleteVirtualRouterOutput{} 2168 } else { 2169 sv = *v 2170 } 2171 2172 for key, value := range shape { 2173 switch key { 2174 case "virtualRouter": 2175 if err := awsRestjson1_deserializeDocumentVirtualRouterData(&sv.VirtualRouter, value); err != nil { 2176 return err 2177 } 2178 2179 default: 2180 _, _ = key, value 2181 2182 } 2183 } 2184 *v = sv 2185 return nil 2186} 2187 2188type awsRestjson1_deserializeOpDeleteVirtualService struct { 2189} 2190 2191func (*awsRestjson1_deserializeOpDeleteVirtualService) ID() string { 2192 return "OperationDeserializer" 2193} 2194 2195func (m *awsRestjson1_deserializeOpDeleteVirtualService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2196 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2197) { 2198 out, metadata, err = next.HandleDeserialize(ctx, in) 2199 if err != nil { 2200 return out, metadata, err 2201 } 2202 2203 response, ok := out.RawResponse.(*smithyhttp.Response) 2204 if !ok { 2205 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2206 } 2207 2208 if response.StatusCode < 200 || response.StatusCode >= 300 { 2209 return out, metadata, awsRestjson1_deserializeOpErrorDeleteVirtualService(response, &metadata) 2210 } 2211 output := &DeleteVirtualServiceOutput{} 2212 out.Result = output 2213 2214 var buff [1024]byte 2215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2216 2217 body := io.TeeReader(response.Body, ringBuffer) 2218 2219 decoder := json.NewDecoder(body) 2220 decoder.UseNumber() 2221 var shape interface{} 2222 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2223 var snapshot bytes.Buffer 2224 io.Copy(&snapshot, ringBuffer) 2225 err = &smithy.DeserializationError{ 2226 Err: fmt.Errorf("failed to decode response body, %w", err), 2227 Snapshot: snapshot.Bytes(), 2228 } 2229 return out, metadata, err 2230 } 2231 2232 err = awsRestjson1_deserializeDocumentVirtualServiceData(&output.VirtualService, shape) 2233 if err != nil { 2234 var snapshot bytes.Buffer 2235 io.Copy(&snapshot, ringBuffer) 2236 return out, metadata, &smithy.DeserializationError{ 2237 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2238 Snapshot: snapshot.Bytes(), 2239 } 2240 } 2241 2242 return out, metadata, err 2243} 2244 2245func awsRestjson1_deserializeOpErrorDeleteVirtualService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2246 var errorBuffer bytes.Buffer 2247 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2248 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2249 } 2250 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2251 2252 errorCode := "UnknownError" 2253 errorMessage := errorCode 2254 2255 code := response.Header.Get("X-Amzn-ErrorType") 2256 if len(code) != 0 { 2257 errorCode = restjson.SanitizeErrorCode(code) 2258 } 2259 2260 var buff [1024]byte 2261 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2262 2263 body := io.TeeReader(errorBody, ringBuffer) 2264 decoder := json.NewDecoder(body) 2265 decoder.UseNumber() 2266 code, message, err := restjson.GetErrorInfo(decoder) 2267 if err != nil { 2268 var snapshot bytes.Buffer 2269 io.Copy(&snapshot, ringBuffer) 2270 err = &smithy.DeserializationError{ 2271 Err: fmt.Errorf("failed to decode response body, %w", err), 2272 Snapshot: snapshot.Bytes(), 2273 } 2274 return err 2275 } 2276 2277 errorBody.Seek(0, io.SeekStart) 2278 if len(code) != 0 { 2279 errorCode = restjson.SanitizeErrorCode(code) 2280 } 2281 if len(message) != 0 { 2282 errorMessage = message 2283 } 2284 2285 switch { 2286 case strings.EqualFold("BadRequestException", errorCode): 2287 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2288 2289 case strings.EqualFold("ForbiddenException", errorCode): 2290 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2291 2292 case strings.EqualFold("InternalServerErrorException", errorCode): 2293 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2294 2295 case strings.EqualFold("NotFoundException", errorCode): 2296 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2297 2298 case strings.EqualFold("ResourceInUseException", errorCode): 2299 return awsRestjson1_deserializeErrorResourceInUseException(response, errorBody) 2300 2301 case strings.EqualFold("ServiceUnavailableException", errorCode): 2302 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2303 2304 case strings.EqualFold("TooManyRequestsException", errorCode): 2305 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2306 2307 default: 2308 genericError := &smithy.GenericAPIError{ 2309 Code: errorCode, 2310 Message: errorMessage, 2311 } 2312 return genericError 2313 2314 } 2315} 2316 2317func awsRestjson1_deserializeOpDocumentDeleteVirtualServiceOutput(v **DeleteVirtualServiceOutput, value interface{}) error { 2318 if v == nil { 2319 return fmt.Errorf("unexpected nil of type %T", v) 2320 } 2321 if value == nil { 2322 return nil 2323 } 2324 2325 shape, ok := value.(map[string]interface{}) 2326 if !ok { 2327 return fmt.Errorf("unexpected JSON type %v", value) 2328 } 2329 2330 var sv *DeleteVirtualServiceOutput 2331 if *v == nil { 2332 sv = &DeleteVirtualServiceOutput{} 2333 } else { 2334 sv = *v 2335 } 2336 2337 for key, value := range shape { 2338 switch key { 2339 case "virtualService": 2340 if err := awsRestjson1_deserializeDocumentVirtualServiceData(&sv.VirtualService, value); err != nil { 2341 return err 2342 } 2343 2344 default: 2345 _, _ = key, value 2346 2347 } 2348 } 2349 *v = sv 2350 return nil 2351} 2352 2353type awsRestjson1_deserializeOpDescribeGatewayRoute struct { 2354} 2355 2356func (*awsRestjson1_deserializeOpDescribeGatewayRoute) ID() string { 2357 return "OperationDeserializer" 2358} 2359 2360func (m *awsRestjson1_deserializeOpDescribeGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2361 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2362) { 2363 out, metadata, err = next.HandleDeserialize(ctx, in) 2364 if err != nil { 2365 return out, metadata, err 2366 } 2367 2368 response, ok := out.RawResponse.(*smithyhttp.Response) 2369 if !ok { 2370 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2371 } 2372 2373 if response.StatusCode < 200 || response.StatusCode >= 300 { 2374 return out, metadata, awsRestjson1_deserializeOpErrorDescribeGatewayRoute(response, &metadata) 2375 } 2376 output := &DescribeGatewayRouteOutput{} 2377 out.Result = output 2378 2379 var buff [1024]byte 2380 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2381 2382 body := io.TeeReader(response.Body, ringBuffer) 2383 2384 decoder := json.NewDecoder(body) 2385 decoder.UseNumber() 2386 var shape interface{} 2387 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2388 var snapshot bytes.Buffer 2389 io.Copy(&snapshot, ringBuffer) 2390 err = &smithy.DeserializationError{ 2391 Err: fmt.Errorf("failed to decode response body, %w", err), 2392 Snapshot: snapshot.Bytes(), 2393 } 2394 return out, metadata, err 2395 } 2396 2397 err = awsRestjson1_deserializeDocumentGatewayRouteData(&output.GatewayRoute, shape) 2398 if err != nil { 2399 var snapshot bytes.Buffer 2400 io.Copy(&snapshot, ringBuffer) 2401 return out, metadata, &smithy.DeserializationError{ 2402 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2403 Snapshot: snapshot.Bytes(), 2404 } 2405 } 2406 2407 return out, metadata, err 2408} 2409 2410func awsRestjson1_deserializeOpErrorDescribeGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2411 var errorBuffer bytes.Buffer 2412 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2413 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2414 } 2415 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2416 2417 errorCode := "UnknownError" 2418 errorMessage := errorCode 2419 2420 code := response.Header.Get("X-Amzn-ErrorType") 2421 if len(code) != 0 { 2422 errorCode = restjson.SanitizeErrorCode(code) 2423 } 2424 2425 var buff [1024]byte 2426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2427 2428 body := io.TeeReader(errorBody, ringBuffer) 2429 decoder := json.NewDecoder(body) 2430 decoder.UseNumber() 2431 code, message, err := restjson.GetErrorInfo(decoder) 2432 if err != nil { 2433 var snapshot bytes.Buffer 2434 io.Copy(&snapshot, ringBuffer) 2435 err = &smithy.DeserializationError{ 2436 Err: fmt.Errorf("failed to decode response body, %w", err), 2437 Snapshot: snapshot.Bytes(), 2438 } 2439 return err 2440 } 2441 2442 errorBody.Seek(0, io.SeekStart) 2443 if len(code) != 0 { 2444 errorCode = restjson.SanitizeErrorCode(code) 2445 } 2446 if len(message) != 0 { 2447 errorMessage = message 2448 } 2449 2450 switch { 2451 case strings.EqualFold("BadRequestException", errorCode): 2452 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2453 2454 case strings.EqualFold("ForbiddenException", errorCode): 2455 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2456 2457 case strings.EqualFold("InternalServerErrorException", errorCode): 2458 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2459 2460 case strings.EqualFold("NotFoundException", errorCode): 2461 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2462 2463 case strings.EqualFold("ServiceUnavailableException", errorCode): 2464 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2465 2466 case strings.EqualFold("TooManyRequestsException", errorCode): 2467 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2468 2469 default: 2470 genericError := &smithy.GenericAPIError{ 2471 Code: errorCode, 2472 Message: errorMessage, 2473 } 2474 return genericError 2475 2476 } 2477} 2478 2479func awsRestjson1_deserializeOpDocumentDescribeGatewayRouteOutput(v **DescribeGatewayRouteOutput, value interface{}) error { 2480 if v == nil { 2481 return fmt.Errorf("unexpected nil of type %T", v) 2482 } 2483 if value == nil { 2484 return nil 2485 } 2486 2487 shape, ok := value.(map[string]interface{}) 2488 if !ok { 2489 return fmt.Errorf("unexpected JSON type %v", value) 2490 } 2491 2492 var sv *DescribeGatewayRouteOutput 2493 if *v == nil { 2494 sv = &DescribeGatewayRouteOutput{} 2495 } else { 2496 sv = *v 2497 } 2498 2499 for key, value := range shape { 2500 switch key { 2501 case "gatewayRoute": 2502 if err := awsRestjson1_deserializeDocumentGatewayRouteData(&sv.GatewayRoute, value); err != nil { 2503 return err 2504 } 2505 2506 default: 2507 _, _ = key, value 2508 2509 } 2510 } 2511 *v = sv 2512 return nil 2513} 2514 2515type awsRestjson1_deserializeOpDescribeMesh struct { 2516} 2517 2518func (*awsRestjson1_deserializeOpDescribeMesh) ID() string { 2519 return "OperationDeserializer" 2520} 2521 2522func (m *awsRestjson1_deserializeOpDescribeMesh) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2524) { 2525 out, metadata, err = next.HandleDeserialize(ctx, in) 2526 if err != nil { 2527 return out, metadata, err 2528 } 2529 2530 response, ok := out.RawResponse.(*smithyhttp.Response) 2531 if !ok { 2532 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2533 } 2534 2535 if response.StatusCode < 200 || response.StatusCode >= 300 { 2536 return out, metadata, awsRestjson1_deserializeOpErrorDescribeMesh(response, &metadata) 2537 } 2538 output := &DescribeMeshOutput{} 2539 out.Result = output 2540 2541 var buff [1024]byte 2542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2543 2544 body := io.TeeReader(response.Body, ringBuffer) 2545 2546 decoder := json.NewDecoder(body) 2547 decoder.UseNumber() 2548 var shape interface{} 2549 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2550 var snapshot bytes.Buffer 2551 io.Copy(&snapshot, ringBuffer) 2552 err = &smithy.DeserializationError{ 2553 Err: fmt.Errorf("failed to decode response body, %w", err), 2554 Snapshot: snapshot.Bytes(), 2555 } 2556 return out, metadata, err 2557 } 2558 2559 err = awsRestjson1_deserializeDocumentMeshData(&output.Mesh, shape) 2560 if err != nil { 2561 var snapshot bytes.Buffer 2562 io.Copy(&snapshot, ringBuffer) 2563 return out, metadata, &smithy.DeserializationError{ 2564 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2565 Snapshot: snapshot.Bytes(), 2566 } 2567 } 2568 2569 return out, metadata, err 2570} 2571 2572func awsRestjson1_deserializeOpErrorDescribeMesh(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2573 var errorBuffer bytes.Buffer 2574 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2575 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2576 } 2577 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2578 2579 errorCode := "UnknownError" 2580 errorMessage := errorCode 2581 2582 code := response.Header.Get("X-Amzn-ErrorType") 2583 if len(code) != 0 { 2584 errorCode = restjson.SanitizeErrorCode(code) 2585 } 2586 2587 var buff [1024]byte 2588 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2589 2590 body := io.TeeReader(errorBody, ringBuffer) 2591 decoder := json.NewDecoder(body) 2592 decoder.UseNumber() 2593 code, message, err := restjson.GetErrorInfo(decoder) 2594 if err != nil { 2595 var snapshot bytes.Buffer 2596 io.Copy(&snapshot, ringBuffer) 2597 err = &smithy.DeserializationError{ 2598 Err: fmt.Errorf("failed to decode response body, %w", err), 2599 Snapshot: snapshot.Bytes(), 2600 } 2601 return err 2602 } 2603 2604 errorBody.Seek(0, io.SeekStart) 2605 if len(code) != 0 { 2606 errorCode = restjson.SanitizeErrorCode(code) 2607 } 2608 if len(message) != 0 { 2609 errorMessage = message 2610 } 2611 2612 switch { 2613 case strings.EqualFold("BadRequestException", errorCode): 2614 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2615 2616 case strings.EqualFold("ForbiddenException", errorCode): 2617 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2618 2619 case strings.EqualFold("InternalServerErrorException", errorCode): 2620 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2621 2622 case strings.EqualFold("NotFoundException", errorCode): 2623 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2624 2625 case strings.EqualFold("ServiceUnavailableException", errorCode): 2626 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2627 2628 case strings.EqualFold("TooManyRequestsException", errorCode): 2629 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2630 2631 default: 2632 genericError := &smithy.GenericAPIError{ 2633 Code: errorCode, 2634 Message: errorMessage, 2635 } 2636 return genericError 2637 2638 } 2639} 2640 2641func awsRestjson1_deserializeOpDocumentDescribeMeshOutput(v **DescribeMeshOutput, value interface{}) error { 2642 if v == nil { 2643 return fmt.Errorf("unexpected nil of type %T", v) 2644 } 2645 if value == nil { 2646 return nil 2647 } 2648 2649 shape, ok := value.(map[string]interface{}) 2650 if !ok { 2651 return fmt.Errorf("unexpected JSON type %v", value) 2652 } 2653 2654 var sv *DescribeMeshOutput 2655 if *v == nil { 2656 sv = &DescribeMeshOutput{} 2657 } else { 2658 sv = *v 2659 } 2660 2661 for key, value := range shape { 2662 switch key { 2663 case "mesh": 2664 if err := awsRestjson1_deserializeDocumentMeshData(&sv.Mesh, value); err != nil { 2665 return err 2666 } 2667 2668 default: 2669 _, _ = key, value 2670 2671 } 2672 } 2673 *v = sv 2674 return nil 2675} 2676 2677type awsRestjson1_deserializeOpDescribeRoute struct { 2678} 2679 2680func (*awsRestjson1_deserializeOpDescribeRoute) ID() string { 2681 return "OperationDeserializer" 2682} 2683 2684func (m *awsRestjson1_deserializeOpDescribeRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2685 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2686) { 2687 out, metadata, err = next.HandleDeserialize(ctx, in) 2688 if err != nil { 2689 return out, metadata, err 2690 } 2691 2692 response, ok := out.RawResponse.(*smithyhttp.Response) 2693 if !ok { 2694 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2695 } 2696 2697 if response.StatusCode < 200 || response.StatusCode >= 300 { 2698 return out, metadata, awsRestjson1_deserializeOpErrorDescribeRoute(response, &metadata) 2699 } 2700 output := &DescribeRouteOutput{} 2701 out.Result = output 2702 2703 var buff [1024]byte 2704 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2705 2706 body := io.TeeReader(response.Body, ringBuffer) 2707 2708 decoder := json.NewDecoder(body) 2709 decoder.UseNumber() 2710 var shape interface{} 2711 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2712 var snapshot bytes.Buffer 2713 io.Copy(&snapshot, ringBuffer) 2714 err = &smithy.DeserializationError{ 2715 Err: fmt.Errorf("failed to decode response body, %w", err), 2716 Snapshot: snapshot.Bytes(), 2717 } 2718 return out, metadata, err 2719 } 2720 2721 err = awsRestjson1_deserializeDocumentRouteData(&output.Route, shape) 2722 if err != nil { 2723 var snapshot bytes.Buffer 2724 io.Copy(&snapshot, ringBuffer) 2725 return out, metadata, &smithy.DeserializationError{ 2726 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2727 Snapshot: snapshot.Bytes(), 2728 } 2729 } 2730 2731 return out, metadata, err 2732} 2733 2734func awsRestjson1_deserializeOpErrorDescribeRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2735 var errorBuffer bytes.Buffer 2736 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2737 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2738 } 2739 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2740 2741 errorCode := "UnknownError" 2742 errorMessage := errorCode 2743 2744 code := response.Header.Get("X-Amzn-ErrorType") 2745 if len(code) != 0 { 2746 errorCode = restjson.SanitizeErrorCode(code) 2747 } 2748 2749 var buff [1024]byte 2750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2751 2752 body := io.TeeReader(errorBody, ringBuffer) 2753 decoder := json.NewDecoder(body) 2754 decoder.UseNumber() 2755 code, message, err := restjson.GetErrorInfo(decoder) 2756 if err != nil { 2757 var snapshot bytes.Buffer 2758 io.Copy(&snapshot, ringBuffer) 2759 err = &smithy.DeserializationError{ 2760 Err: fmt.Errorf("failed to decode response body, %w", err), 2761 Snapshot: snapshot.Bytes(), 2762 } 2763 return err 2764 } 2765 2766 errorBody.Seek(0, io.SeekStart) 2767 if len(code) != 0 { 2768 errorCode = restjson.SanitizeErrorCode(code) 2769 } 2770 if len(message) != 0 { 2771 errorMessage = message 2772 } 2773 2774 switch { 2775 case strings.EqualFold("BadRequestException", errorCode): 2776 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2777 2778 case strings.EqualFold("ForbiddenException", errorCode): 2779 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2780 2781 case strings.EqualFold("InternalServerErrorException", errorCode): 2782 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2783 2784 case strings.EqualFold("NotFoundException", errorCode): 2785 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2786 2787 case strings.EqualFold("ServiceUnavailableException", errorCode): 2788 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2789 2790 case strings.EqualFold("TooManyRequestsException", errorCode): 2791 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2792 2793 default: 2794 genericError := &smithy.GenericAPIError{ 2795 Code: errorCode, 2796 Message: errorMessage, 2797 } 2798 return genericError 2799 2800 } 2801} 2802 2803func awsRestjson1_deserializeOpDocumentDescribeRouteOutput(v **DescribeRouteOutput, value interface{}) error { 2804 if v == nil { 2805 return fmt.Errorf("unexpected nil of type %T", v) 2806 } 2807 if value == nil { 2808 return nil 2809 } 2810 2811 shape, ok := value.(map[string]interface{}) 2812 if !ok { 2813 return fmt.Errorf("unexpected JSON type %v", value) 2814 } 2815 2816 var sv *DescribeRouteOutput 2817 if *v == nil { 2818 sv = &DescribeRouteOutput{} 2819 } else { 2820 sv = *v 2821 } 2822 2823 for key, value := range shape { 2824 switch key { 2825 case "route": 2826 if err := awsRestjson1_deserializeDocumentRouteData(&sv.Route, value); err != nil { 2827 return err 2828 } 2829 2830 default: 2831 _, _ = key, value 2832 2833 } 2834 } 2835 *v = sv 2836 return nil 2837} 2838 2839type awsRestjson1_deserializeOpDescribeVirtualGateway struct { 2840} 2841 2842func (*awsRestjson1_deserializeOpDescribeVirtualGateway) ID() string { 2843 return "OperationDeserializer" 2844} 2845 2846func (m *awsRestjson1_deserializeOpDescribeVirtualGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2847 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2848) { 2849 out, metadata, err = next.HandleDeserialize(ctx, in) 2850 if err != nil { 2851 return out, metadata, err 2852 } 2853 2854 response, ok := out.RawResponse.(*smithyhttp.Response) 2855 if !ok { 2856 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2857 } 2858 2859 if response.StatusCode < 200 || response.StatusCode >= 300 { 2860 return out, metadata, awsRestjson1_deserializeOpErrorDescribeVirtualGateway(response, &metadata) 2861 } 2862 output := &DescribeVirtualGatewayOutput{} 2863 out.Result = output 2864 2865 var buff [1024]byte 2866 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2867 2868 body := io.TeeReader(response.Body, ringBuffer) 2869 2870 decoder := json.NewDecoder(body) 2871 decoder.UseNumber() 2872 var shape interface{} 2873 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2874 var snapshot bytes.Buffer 2875 io.Copy(&snapshot, ringBuffer) 2876 err = &smithy.DeserializationError{ 2877 Err: fmt.Errorf("failed to decode response body, %w", err), 2878 Snapshot: snapshot.Bytes(), 2879 } 2880 return out, metadata, err 2881 } 2882 2883 err = awsRestjson1_deserializeDocumentVirtualGatewayData(&output.VirtualGateway, shape) 2884 if err != nil { 2885 var snapshot bytes.Buffer 2886 io.Copy(&snapshot, ringBuffer) 2887 return out, metadata, &smithy.DeserializationError{ 2888 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2889 Snapshot: snapshot.Bytes(), 2890 } 2891 } 2892 2893 return out, metadata, err 2894} 2895 2896func awsRestjson1_deserializeOpErrorDescribeVirtualGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2897 var errorBuffer bytes.Buffer 2898 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2899 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2900 } 2901 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2902 2903 errorCode := "UnknownError" 2904 errorMessage := errorCode 2905 2906 code := response.Header.Get("X-Amzn-ErrorType") 2907 if len(code) != 0 { 2908 errorCode = restjson.SanitizeErrorCode(code) 2909 } 2910 2911 var buff [1024]byte 2912 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2913 2914 body := io.TeeReader(errorBody, ringBuffer) 2915 decoder := json.NewDecoder(body) 2916 decoder.UseNumber() 2917 code, message, err := restjson.GetErrorInfo(decoder) 2918 if err != nil { 2919 var snapshot bytes.Buffer 2920 io.Copy(&snapshot, ringBuffer) 2921 err = &smithy.DeserializationError{ 2922 Err: fmt.Errorf("failed to decode response body, %w", err), 2923 Snapshot: snapshot.Bytes(), 2924 } 2925 return err 2926 } 2927 2928 errorBody.Seek(0, io.SeekStart) 2929 if len(code) != 0 { 2930 errorCode = restjson.SanitizeErrorCode(code) 2931 } 2932 if len(message) != 0 { 2933 errorMessage = message 2934 } 2935 2936 switch { 2937 case strings.EqualFold("BadRequestException", errorCode): 2938 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2939 2940 case strings.EqualFold("ForbiddenException", errorCode): 2941 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 2942 2943 case strings.EqualFold("InternalServerErrorException", errorCode): 2944 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2945 2946 case strings.EqualFold("NotFoundException", errorCode): 2947 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 2948 2949 case strings.EqualFold("ServiceUnavailableException", errorCode): 2950 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 2951 2952 case strings.EqualFold("TooManyRequestsException", errorCode): 2953 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 2954 2955 default: 2956 genericError := &smithy.GenericAPIError{ 2957 Code: errorCode, 2958 Message: errorMessage, 2959 } 2960 return genericError 2961 2962 } 2963} 2964 2965func awsRestjson1_deserializeOpDocumentDescribeVirtualGatewayOutput(v **DescribeVirtualGatewayOutput, value interface{}) error { 2966 if v == nil { 2967 return fmt.Errorf("unexpected nil of type %T", v) 2968 } 2969 if value == nil { 2970 return nil 2971 } 2972 2973 shape, ok := value.(map[string]interface{}) 2974 if !ok { 2975 return fmt.Errorf("unexpected JSON type %v", value) 2976 } 2977 2978 var sv *DescribeVirtualGatewayOutput 2979 if *v == nil { 2980 sv = &DescribeVirtualGatewayOutput{} 2981 } else { 2982 sv = *v 2983 } 2984 2985 for key, value := range shape { 2986 switch key { 2987 case "virtualGateway": 2988 if err := awsRestjson1_deserializeDocumentVirtualGatewayData(&sv.VirtualGateway, value); err != nil { 2989 return err 2990 } 2991 2992 default: 2993 _, _ = key, value 2994 2995 } 2996 } 2997 *v = sv 2998 return nil 2999} 3000 3001type awsRestjson1_deserializeOpDescribeVirtualNode struct { 3002} 3003 3004func (*awsRestjson1_deserializeOpDescribeVirtualNode) ID() string { 3005 return "OperationDeserializer" 3006} 3007 3008func (m *awsRestjson1_deserializeOpDescribeVirtualNode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3009 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3010) { 3011 out, metadata, err = next.HandleDeserialize(ctx, in) 3012 if err != nil { 3013 return out, metadata, err 3014 } 3015 3016 response, ok := out.RawResponse.(*smithyhttp.Response) 3017 if !ok { 3018 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3019 } 3020 3021 if response.StatusCode < 200 || response.StatusCode >= 300 { 3022 return out, metadata, awsRestjson1_deserializeOpErrorDescribeVirtualNode(response, &metadata) 3023 } 3024 output := &DescribeVirtualNodeOutput{} 3025 out.Result = output 3026 3027 var buff [1024]byte 3028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3029 3030 body := io.TeeReader(response.Body, ringBuffer) 3031 3032 decoder := json.NewDecoder(body) 3033 decoder.UseNumber() 3034 var shape interface{} 3035 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3036 var snapshot bytes.Buffer 3037 io.Copy(&snapshot, ringBuffer) 3038 err = &smithy.DeserializationError{ 3039 Err: fmt.Errorf("failed to decode response body, %w", err), 3040 Snapshot: snapshot.Bytes(), 3041 } 3042 return out, metadata, err 3043 } 3044 3045 err = awsRestjson1_deserializeDocumentVirtualNodeData(&output.VirtualNode, shape) 3046 if err != nil { 3047 var snapshot bytes.Buffer 3048 io.Copy(&snapshot, ringBuffer) 3049 return out, metadata, &smithy.DeserializationError{ 3050 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3051 Snapshot: snapshot.Bytes(), 3052 } 3053 } 3054 3055 return out, metadata, err 3056} 3057 3058func awsRestjson1_deserializeOpErrorDescribeVirtualNode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3059 var errorBuffer bytes.Buffer 3060 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3061 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3062 } 3063 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3064 3065 errorCode := "UnknownError" 3066 errorMessage := errorCode 3067 3068 code := response.Header.Get("X-Amzn-ErrorType") 3069 if len(code) != 0 { 3070 errorCode = restjson.SanitizeErrorCode(code) 3071 } 3072 3073 var buff [1024]byte 3074 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3075 3076 body := io.TeeReader(errorBody, ringBuffer) 3077 decoder := json.NewDecoder(body) 3078 decoder.UseNumber() 3079 code, message, err := restjson.GetErrorInfo(decoder) 3080 if err != nil { 3081 var snapshot bytes.Buffer 3082 io.Copy(&snapshot, ringBuffer) 3083 err = &smithy.DeserializationError{ 3084 Err: fmt.Errorf("failed to decode response body, %w", err), 3085 Snapshot: snapshot.Bytes(), 3086 } 3087 return err 3088 } 3089 3090 errorBody.Seek(0, io.SeekStart) 3091 if len(code) != 0 { 3092 errorCode = restjson.SanitizeErrorCode(code) 3093 } 3094 if len(message) != 0 { 3095 errorMessage = message 3096 } 3097 3098 switch { 3099 case strings.EqualFold("BadRequestException", errorCode): 3100 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3101 3102 case strings.EqualFold("ForbiddenException", errorCode): 3103 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3104 3105 case strings.EqualFold("InternalServerErrorException", errorCode): 3106 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3107 3108 case strings.EqualFold("NotFoundException", errorCode): 3109 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3110 3111 case strings.EqualFold("ServiceUnavailableException", errorCode): 3112 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3113 3114 case strings.EqualFold("TooManyRequestsException", errorCode): 3115 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3116 3117 default: 3118 genericError := &smithy.GenericAPIError{ 3119 Code: errorCode, 3120 Message: errorMessage, 3121 } 3122 return genericError 3123 3124 } 3125} 3126 3127func awsRestjson1_deserializeOpDocumentDescribeVirtualNodeOutput(v **DescribeVirtualNodeOutput, value interface{}) error { 3128 if v == nil { 3129 return fmt.Errorf("unexpected nil of type %T", v) 3130 } 3131 if value == nil { 3132 return nil 3133 } 3134 3135 shape, ok := value.(map[string]interface{}) 3136 if !ok { 3137 return fmt.Errorf("unexpected JSON type %v", value) 3138 } 3139 3140 var sv *DescribeVirtualNodeOutput 3141 if *v == nil { 3142 sv = &DescribeVirtualNodeOutput{} 3143 } else { 3144 sv = *v 3145 } 3146 3147 for key, value := range shape { 3148 switch key { 3149 case "virtualNode": 3150 if err := awsRestjson1_deserializeDocumentVirtualNodeData(&sv.VirtualNode, value); err != nil { 3151 return err 3152 } 3153 3154 default: 3155 _, _ = key, value 3156 3157 } 3158 } 3159 *v = sv 3160 return nil 3161} 3162 3163type awsRestjson1_deserializeOpDescribeVirtualRouter struct { 3164} 3165 3166func (*awsRestjson1_deserializeOpDescribeVirtualRouter) ID() string { 3167 return "OperationDeserializer" 3168} 3169 3170func (m *awsRestjson1_deserializeOpDescribeVirtualRouter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3171 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3172) { 3173 out, metadata, err = next.HandleDeserialize(ctx, in) 3174 if err != nil { 3175 return out, metadata, err 3176 } 3177 3178 response, ok := out.RawResponse.(*smithyhttp.Response) 3179 if !ok { 3180 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3181 } 3182 3183 if response.StatusCode < 200 || response.StatusCode >= 300 { 3184 return out, metadata, awsRestjson1_deserializeOpErrorDescribeVirtualRouter(response, &metadata) 3185 } 3186 output := &DescribeVirtualRouterOutput{} 3187 out.Result = output 3188 3189 var buff [1024]byte 3190 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3191 3192 body := io.TeeReader(response.Body, ringBuffer) 3193 3194 decoder := json.NewDecoder(body) 3195 decoder.UseNumber() 3196 var shape interface{} 3197 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3198 var snapshot bytes.Buffer 3199 io.Copy(&snapshot, ringBuffer) 3200 err = &smithy.DeserializationError{ 3201 Err: fmt.Errorf("failed to decode response body, %w", err), 3202 Snapshot: snapshot.Bytes(), 3203 } 3204 return out, metadata, err 3205 } 3206 3207 err = awsRestjson1_deserializeDocumentVirtualRouterData(&output.VirtualRouter, shape) 3208 if err != nil { 3209 var snapshot bytes.Buffer 3210 io.Copy(&snapshot, ringBuffer) 3211 return out, metadata, &smithy.DeserializationError{ 3212 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3213 Snapshot: snapshot.Bytes(), 3214 } 3215 } 3216 3217 return out, metadata, err 3218} 3219 3220func awsRestjson1_deserializeOpErrorDescribeVirtualRouter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3221 var errorBuffer bytes.Buffer 3222 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3223 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3224 } 3225 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3226 3227 errorCode := "UnknownError" 3228 errorMessage := errorCode 3229 3230 code := response.Header.Get("X-Amzn-ErrorType") 3231 if len(code) != 0 { 3232 errorCode = restjson.SanitizeErrorCode(code) 3233 } 3234 3235 var buff [1024]byte 3236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3237 3238 body := io.TeeReader(errorBody, ringBuffer) 3239 decoder := json.NewDecoder(body) 3240 decoder.UseNumber() 3241 code, message, err := restjson.GetErrorInfo(decoder) 3242 if err != nil { 3243 var snapshot bytes.Buffer 3244 io.Copy(&snapshot, ringBuffer) 3245 err = &smithy.DeserializationError{ 3246 Err: fmt.Errorf("failed to decode response body, %w", err), 3247 Snapshot: snapshot.Bytes(), 3248 } 3249 return err 3250 } 3251 3252 errorBody.Seek(0, io.SeekStart) 3253 if len(code) != 0 { 3254 errorCode = restjson.SanitizeErrorCode(code) 3255 } 3256 if len(message) != 0 { 3257 errorMessage = message 3258 } 3259 3260 switch { 3261 case strings.EqualFold("BadRequestException", errorCode): 3262 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3263 3264 case strings.EqualFold("ForbiddenException", errorCode): 3265 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3266 3267 case strings.EqualFold("InternalServerErrorException", errorCode): 3268 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3269 3270 case strings.EqualFold("NotFoundException", errorCode): 3271 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3272 3273 case strings.EqualFold("ServiceUnavailableException", errorCode): 3274 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3275 3276 case strings.EqualFold("TooManyRequestsException", errorCode): 3277 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3278 3279 default: 3280 genericError := &smithy.GenericAPIError{ 3281 Code: errorCode, 3282 Message: errorMessage, 3283 } 3284 return genericError 3285 3286 } 3287} 3288 3289func awsRestjson1_deserializeOpDocumentDescribeVirtualRouterOutput(v **DescribeVirtualRouterOutput, value interface{}) error { 3290 if v == nil { 3291 return fmt.Errorf("unexpected nil of type %T", v) 3292 } 3293 if value == nil { 3294 return nil 3295 } 3296 3297 shape, ok := value.(map[string]interface{}) 3298 if !ok { 3299 return fmt.Errorf("unexpected JSON type %v", value) 3300 } 3301 3302 var sv *DescribeVirtualRouterOutput 3303 if *v == nil { 3304 sv = &DescribeVirtualRouterOutput{} 3305 } else { 3306 sv = *v 3307 } 3308 3309 for key, value := range shape { 3310 switch key { 3311 case "virtualRouter": 3312 if err := awsRestjson1_deserializeDocumentVirtualRouterData(&sv.VirtualRouter, value); err != nil { 3313 return err 3314 } 3315 3316 default: 3317 _, _ = key, value 3318 3319 } 3320 } 3321 *v = sv 3322 return nil 3323} 3324 3325type awsRestjson1_deserializeOpDescribeVirtualService struct { 3326} 3327 3328func (*awsRestjson1_deserializeOpDescribeVirtualService) ID() string { 3329 return "OperationDeserializer" 3330} 3331 3332func (m *awsRestjson1_deserializeOpDescribeVirtualService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3333 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3334) { 3335 out, metadata, err = next.HandleDeserialize(ctx, in) 3336 if err != nil { 3337 return out, metadata, err 3338 } 3339 3340 response, ok := out.RawResponse.(*smithyhttp.Response) 3341 if !ok { 3342 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3343 } 3344 3345 if response.StatusCode < 200 || response.StatusCode >= 300 { 3346 return out, metadata, awsRestjson1_deserializeOpErrorDescribeVirtualService(response, &metadata) 3347 } 3348 output := &DescribeVirtualServiceOutput{} 3349 out.Result = output 3350 3351 var buff [1024]byte 3352 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3353 3354 body := io.TeeReader(response.Body, ringBuffer) 3355 3356 decoder := json.NewDecoder(body) 3357 decoder.UseNumber() 3358 var shape interface{} 3359 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3360 var snapshot bytes.Buffer 3361 io.Copy(&snapshot, ringBuffer) 3362 err = &smithy.DeserializationError{ 3363 Err: fmt.Errorf("failed to decode response body, %w", err), 3364 Snapshot: snapshot.Bytes(), 3365 } 3366 return out, metadata, err 3367 } 3368 3369 err = awsRestjson1_deserializeDocumentVirtualServiceData(&output.VirtualService, shape) 3370 if err != nil { 3371 var snapshot bytes.Buffer 3372 io.Copy(&snapshot, ringBuffer) 3373 return out, metadata, &smithy.DeserializationError{ 3374 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3375 Snapshot: snapshot.Bytes(), 3376 } 3377 } 3378 3379 return out, metadata, err 3380} 3381 3382func awsRestjson1_deserializeOpErrorDescribeVirtualService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3383 var errorBuffer bytes.Buffer 3384 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3385 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3386 } 3387 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3388 3389 errorCode := "UnknownError" 3390 errorMessage := errorCode 3391 3392 code := response.Header.Get("X-Amzn-ErrorType") 3393 if len(code) != 0 { 3394 errorCode = restjson.SanitizeErrorCode(code) 3395 } 3396 3397 var buff [1024]byte 3398 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3399 3400 body := io.TeeReader(errorBody, ringBuffer) 3401 decoder := json.NewDecoder(body) 3402 decoder.UseNumber() 3403 code, message, err := restjson.GetErrorInfo(decoder) 3404 if err != nil { 3405 var snapshot bytes.Buffer 3406 io.Copy(&snapshot, ringBuffer) 3407 err = &smithy.DeserializationError{ 3408 Err: fmt.Errorf("failed to decode response body, %w", err), 3409 Snapshot: snapshot.Bytes(), 3410 } 3411 return err 3412 } 3413 3414 errorBody.Seek(0, io.SeekStart) 3415 if len(code) != 0 { 3416 errorCode = restjson.SanitizeErrorCode(code) 3417 } 3418 if len(message) != 0 { 3419 errorMessage = message 3420 } 3421 3422 switch { 3423 case strings.EqualFold("BadRequestException", errorCode): 3424 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3425 3426 case strings.EqualFold("ForbiddenException", errorCode): 3427 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3428 3429 case strings.EqualFold("InternalServerErrorException", errorCode): 3430 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3431 3432 case strings.EqualFold("NotFoundException", errorCode): 3433 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3434 3435 case strings.EqualFold("ServiceUnavailableException", errorCode): 3436 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3437 3438 case strings.EqualFold("TooManyRequestsException", errorCode): 3439 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3440 3441 default: 3442 genericError := &smithy.GenericAPIError{ 3443 Code: errorCode, 3444 Message: errorMessage, 3445 } 3446 return genericError 3447 3448 } 3449} 3450 3451func awsRestjson1_deserializeOpDocumentDescribeVirtualServiceOutput(v **DescribeVirtualServiceOutput, value interface{}) error { 3452 if v == nil { 3453 return fmt.Errorf("unexpected nil of type %T", v) 3454 } 3455 if value == nil { 3456 return nil 3457 } 3458 3459 shape, ok := value.(map[string]interface{}) 3460 if !ok { 3461 return fmt.Errorf("unexpected JSON type %v", value) 3462 } 3463 3464 var sv *DescribeVirtualServiceOutput 3465 if *v == nil { 3466 sv = &DescribeVirtualServiceOutput{} 3467 } else { 3468 sv = *v 3469 } 3470 3471 for key, value := range shape { 3472 switch key { 3473 case "virtualService": 3474 if err := awsRestjson1_deserializeDocumentVirtualServiceData(&sv.VirtualService, value); err != nil { 3475 return err 3476 } 3477 3478 default: 3479 _, _ = key, value 3480 3481 } 3482 } 3483 *v = sv 3484 return nil 3485} 3486 3487type awsRestjson1_deserializeOpListGatewayRoutes struct { 3488} 3489 3490func (*awsRestjson1_deserializeOpListGatewayRoutes) ID() string { 3491 return "OperationDeserializer" 3492} 3493 3494func (m *awsRestjson1_deserializeOpListGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3495 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3496) { 3497 out, metadata, err = next.HandleDeserialize(ctx, in) 3498 if err != nil { 3499 return out, metadata, err 3500 } 3501 3502 response, ok := out.RawResponse.(*smithyhttp.Response) 3503 if !ok { 3504 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3505 } 3506 3507 if response.StatusCode < 200 || response.StatusCode >= 300 { 3508 return out, metadata, awsRestjson1_deserializeOpErrorListGatewayRoutes(response, &metadata) 3509 } 3510 output := &ListGatewayRoutesOutput{} 3511 out.Result = output 3512 3513 var buff [1024]byte 3514 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3515 3516 body := io.TeeReader(response.Body, ringBuffer) 3517 3518 decoder := json.NewDecoder(body) 3519 decoder.UseNumber() 3520 var shape interface{} 3521 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3522 var snapshot bytes.Buffer 3523 io.Copy(&snapshot, ringBuffer) 3524 err = &smithy.DeserializationError{ 3525 Err: fmt.Errorf("failed to decode response body, %w", err), 3526 Snapshot: snapshot.Bytes(), 3527 } 3528 return out, metadata, err 3529 } 3530 3531 err = awsRestjson1_deserializeOpDocumentListGatewayRoutesOutput(&output, shape) 3532 if err != nil { 3533 var snapshot bytes.Buffer 3534 io.Copy(&snapshot, ringBuffer) 3535 return out, metadata, &smithy.DeserializationError{ 3536 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3537 Snapshot: snapshot.Bytes(), 3538 } 3539 } 3540 3541 return out, metadata, err 3542} 3543 3544func awsRestjson1_deserializeOpErrorListGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3545 var errorBuffer bytes.Buffer 3546 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3547 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3548 } 3549 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3550 3551 errorCode := "UnknownError" 3552 errorMessage := errorCode 3553 3554 code := response.Header.Get("X-Amzn-ErrorType") 3555 if len(code) != 0 { 3556 errorCode = restjson.SanitizeErrorCode(code) 3557 } 3558 3559 var buff [1024]byte 3560 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3561 3562 body := io.TeeReader(errorBody, ringBuffer) 3563 decoder := json.NewDecoder(body) 3564 decoder.UseNumber() 3565 code, message, err := restjson.GetErrorInfo(decoder) 3566 if err != nil { 3567 var snapshot bytes.Buffer 3568 io.Copy(&snapshot, ringBuffer) 3569 err = &smithy.DeserializationError{ 3570 Err: fmt.Errorf("failed to decode response body, %w", err), 3571 Snapshot: snapshot.Bytes(), 3572 } 3573 return err 3574 } 3575 3576 errorBody.Seek(0, io.SeekStart) 3577 if len(code) != 0 { 3578 errorCode = restjson.SanitizeErrorCode(code) 3579 } 3580 if len(message) != 0 { 3581 errorMessage = message 3582 } 3583 3584 switch { 3585 case strings.EqualFold("BadRequestException", errorCode): 3586 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3587 3588 case strings.EqualFold("ForbiddenException", errorCode): 3589 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3590 3591 case strings.EqualFold("InternalServerErrorException", errorCode): 3592 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3593 3594 case strings.EqualFold("NotFoundException", errorCode): 3595 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3596 3597 case strings.EqualFold("ServiceUnavailableException", errorCode): 3598 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3599 3600 case strings.EqualFold("TooManyRequestsException", errorCode): 3601 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3602 3603 default: 3604 genericError := &smithy.GenericAPIError{ 3605 Code: errorCode, 3606 Message: errorMessage, 3607 } 3608 return genericError 3609 3610 } 3611} 3612 3613func awsRestjson1_deserializeOpDocumentListGatewayRoutesOutput(v **ListGatewayRoutesOutput, value interface{}) error { 3614 if v == nil { 3615 return fmt.Errorf("unexpected nil of type %T", v) 3616 } 3617 if value == nil { 3618 return nil 3619 } 3620 3621 shape, ok := value.(map[string]interface{}) 3622 if !ok { 3623 return fmt.Errorf("unexpected JSON type %v", value) 3624 } 3625 3626 var sv *ListGatewayRoutesOutput 3627 if *v == nil { 3628 sv = &ListGatewayRoutesOutput{} 3629 } else { 3630 sv = *v 3631 } 3632 3633 for key, value := range shape { 3634 switch key { 3635 case "gatewayRoutes": 3636 if err := awsRestjson1_deserializeDocumentGatewayRouteList(&sv.GatewayRoutes, value); err != nil { 3637 return err 3638 } 3639 3640 case "nextToken": 3641 if value != nil { 3642 jtv, ok := value.(string) 3643 if !ok { 3644 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3645 } 3646 sv.NextToken = ptr.String(jtv) 3647 } 3648 3649 default: 3650 _, _ = key, value 3651 3652 } 3653 } 3654 *v = sv 3655 return nil 3656} 3657 3658type awsRestjson1_deserializeOpListMeshes struct { 3659} 3660 3661func (*awsRestjson1_deserializeOpListMeshes) ID() string { 3662 return "OperationDeserializer" 3663} 3664 3665func (m *awsRestjson1_deserializeOpListMeshes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3666 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3667) { 3668 out, metadata, err = next.HandleDeserialize(ctx, in) 3669 if err != nil { 3670 return out, metadata, err 3671 } 3672 3673 response, ok := out.RawResponse.(*smithyhttp.Response) 3674 if !ok { 3675 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3676 } 3677 3678 if response.StatusCode < 200 || response.StatusCode >= 300 { 3679 return out, metadata, awsRestjson1_deserializeOpErrorListMeshes(response, &metadata) 3680 } 3681 output := &ListMeshesOutput{} 3682 out.Result = output 3683 3684 var buff [1024]byte 3685 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3686 3687 body := io.TeeReader(response.Body, ringBuffer) 3688 3689 decoder := json.NewDecoder(body) 3690 decoder.UseNumber() 3691 var shape interface{} 3692 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3693 var snapshot bytes.Buffer 3694 io.Copy(&snapshot, ringBuffer) 3695 err = &smithy.DeserializationError{ 3696 Err: fmt.Errorf("failed to decode response body, %w", err), 3697 Snapshot: snapshot.Bytes(), 3698 } 3699 return out, metadata, err 3700 } 3701 3702 err = awsRestjson1_deserializeOpDocumentListMeshesOutput(&output, shape) 3703 if err != nil { 3704 var snapshot bytes.Buffer 3705 io.Copy(&snapshot, ringBuffer) 3706 return out, metadata, &smithy.DeserializationError{ 3707 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3708 Snapshot: snapshot.Bytes(), 3709 } 3710 } 3711 3712 return out, metadata, err 3713} 3714 3715func awsRestjson1_deserializeOpErrorListMeshes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3716 var errorBuffer bytes.Buffer 3717 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3718 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3719 } 3720 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3721 3722 errorCode := "UnknownError" 3723 errorMessage := errorCode 3724 3725 code := response.Header.Get("X-Amzn-ErrorType") 3726 if len(code) != 0 { 3727 errorCode = restjson.SanitizeErrorCode(code) 3728 } 3729 3730 var buff [1024]byte 3731 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3732 3733 body := io.TeeReader(errorBody, ringBuffer) 3734 decoder := json.NewDecoder(body) 3735 decoder.UseNumber() 3736 code, message, err := restjson.GetErrorInfo(decoder) 3737 if err != nil { 3738 var snapshot bytes.Buffer 3739 io.Copy(&snapshot, ringBuffer) 3740 err = &smithy.DeserializationError{ 3741 Err: fmt.Errorf("failed to decode response body, %w", err), 3742 Snapshot: snapshot.Bytes(), 3743 } 3744 return err 3745 } 3746 3747 errorBody.Seek(0, io.SeekStart) 3748 if len(code) != 0 { 3749 errorCode = restjson.SanitizeErrorCode(code) 3750 } 3751 if len(message) != 0 { 3752 errorMessage = message 3753 } 3754 3755 switch { 3756 case strings.EqualFold("BadRequestException", errorCode): 3757 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3758 3759 case strings.EqualFold("ForbiddenException", errorCode): 3760 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3761 3762 case strings.EqualFold("InternalServerErrorException", errorCode): 3763 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3764 3765 case strings.EqualFold("NotFoundException", errorCode): 3766 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3767 3768 case strings.EqualFold("ServiceUnavailableException", errorCode): 3769 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3770 3771 case strings.EqualFold("TooManyRequestsException", errorCode): 3772 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3773 3774 default: 3775 genericError := &smithy.GenericAPIError{ 3776 Code: errorCode, 3777 Message: errorMessage, 3778 } 3779 return genericError 3780 3781 } 3782} 3783 3784func awsRestjson1_deserializeOpDocumentListMeshesOutput(v **ListMeshesOutput, value interface{}) error { 3785 if v == nil { 3786 return fmt.Errorf("unexpected nil of type %T", v) 3787 } 3788 if value == nil { 3789 return nil 3790 } 3791 3792 shape, ok := value.(map[string]interface{}) 3793 if !ok { 3794 return fmt.Errorf("unexpected JSON type %v", value) 3795 } 3796 3797 var sv *ListMeshesOutput 3798 if *v == nil { 3799 sv = &ListMeshesOutput{} 3800 } else { 3801 sv = *v 3802 } 3803 3804 for key, value := range shape { 3805 switch key { 3806 case "meshes": 3807 if err := awsRestjson1_deserializeDocumentMeshList(&sv.Meshes, value); err != nil { 3808 return err 3809 } 3810 3811 case "nextToken": 3812 if value != nil { 3813 jtv, ok := value.(string) 3814 if !ok { 3815 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3816 } 3817 sv.NextToken = ptr.String(jtv) 3818 } 3819 3820 default: 3821 _, _ = key, value 3822 3823 } 3824 } 3825 *v = sv 3826 return nil 3827} 3828 3829type awsRestjson1_deserializeOpListRoutes struct { 3830} 3831 3832func (*awsRestjson1_deserializeOpListRoutes) ID() string { 3833 return "OperationDeserializer" 3834} 3835 3836func (m *awsRestjson1_deserializeOpListRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3837 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3838) { 3839 out, metadata, err = next.HandleDeserialize(ctx, in) 3840 if err != nil { 3841 return out, metadata, err 3842 } 3843 3844 response, ok := out.RawResponse.(*smithyhttp.Response) 3845 if !ok { 3846 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3847 } 3848 3849 if response.StatusCode < 200 || response.StatusCode >= 300 { 3850 return out, metadata, awsRestjson1_deserializeOpErrorListRoutes(response, &metadata) 3851 } 3852 output := &ListRoutesOutput{} 3853 out.Result = output 3854 3855 var buff [1024]byte 3856 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3857 3858 body := io.TeeReader(response.Body, ringBuffer) 3859 3860 decoder := json.NewDecoder(body) 3861 decoder.UseNumber() 3862 var shape interface{} 3863 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3864 var snapshot bytes.Buffer 3865 io.Copy(&snapshot, ringBuffer) 3866 err = &smithy.DeserializationError{ 3867 Err: fmt.Errorf("failed to decode response body, %w", err), 3868 Snapshot: snapshot.Bytes(), 3869 } 3870 return out, metadata, err 3871 } 3872 3873 err = awsRestjson1_deserializeOpDocumentListRoutesOutput(&output, shape) 3874 if err != nil { 3875 var snapshot bytes.Buffer 3876 io.Copy(&snapshot, ringBuffer) 3877 return out, metadata, &smithy.DeserializationError{ 3878 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3879 Snapshot: snapshot.Bytes(), 3880 } 3881 } 3882 3883 return out, metadata, err 3884} 3885 3886func awsRestjson1_deserializeOpErrorListRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3887 var errorBuffer bytes.Buffer 3888 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3889 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3890 } 3891 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3892 3893 errorCode := "UnknownError" 3894 errorMessage := errorCode 3895 3896 code := response.Header.Get("X-Amzn-ErrorType") 3897 if len(code) != 0 { 3898 errorCode = restjson.SanitizeErrorCode(code) 3899 } 3900 3901 var buff [1024]byte 3902 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3903 3904 body := io.TeeReader(errorBody, ringBuffer) 3905 decoder := json.NewDecoder(body) 3906 decoder.UseNumber() 3907 code, message, err := restjson.GetErrorInfo(decoder) 3908 if err != nil { 3909 var snapshot bytes.Buffer 3910 io.Copy(&snapshot, ringBuffer) 3911 err = &smithy.DeserializationError{ 3912 Err: fmt.Errorf("failed to decode response body, %w", err), 3913 Snapshot: snapshot.Bytes(), 3914 } 3915 return err 3916 } 3917 3918 errorBody.Seek(0, io.SeekStart) 3919 if len(code) != 0 { 3920 errorCode = restjson.SanitizeErrorCode(code) 3921 } 3922 if len(message) != 0 { 3923 errorMessage = message 3924 } 3925 3926 switch { 3927 case strings.EqualFold("BadRequestException", errorCode): 3928 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3929 3930 case strings.EqualFold("ForbiddenException", errorCode): 3931 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 3932 3933 case strings.EqualFold("InternalServerErrorException", errorCode): 3934 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3935 3936 case strings.EqualFold("NotFoundException", errorCode): 3937 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 3938 3939 case strings.EqualFold("ServiceUnavailableException", errorCode): 3940 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 3941 3942 case strings.EqualFold("TooManyRequestsException", errorCode): 3943 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 3944 3945 default: 3946 genericError := &smithy.GenericAPIError{ 3947 Code: errorCode, 3948 Message: errorMessage, 3949 } 3950 return genericError 3951 3952 } 3953} 3954 3955func awsRestjson1_deserializeOpDocumentListRoutesOutput(v **ListRoutesOutput, value interface{}) error { 3956 if v == nil { 3957 return fmt.Errorf("unexpected nil of type %T", v) 3958 } 3959 if value == nil { 3960 return nil 3961 } 3962 3963 shape, ok := value.(map[string]interface{}) 3964 if !ok { 3965 return fmt.Errorf("unexpected JSON type %v", value) 3966 } 3967 3968 var sv *ListRoutesOutput 3969 if *v == nil { 3970 sv = &ListRoutesOutput{} 3971 } else { 3972 sv = *v 3973 } 3974 3975 for key, value := range shape { 3976 switch key { 3977 case "nextToken": 3978 if value != nil { 3979 jtv, ok := value.(string) 3980 if !ok { 3981 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3982 } 3983 sv.NextToken = ptr.String(jtv) 3984 } 3985 3986 case "routes": 3987 if err := awsRestjson1_deserializeDocumentRouteList(&sv.Routes, value); err != nil { 3988 return err 3989 } 3990 3991 default: 3992 _, _ = key, value 3993 3994 } 3995 } 3996 *v = sv 3997 return nil 3998} 3999 4000type awsRestjson1_deserializeOpListTagsForResource struct { 4001} 4002 4003func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 4004 return "OperationDeserializer" 4005} 4006 4007func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4008 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4009) { 4010 out, metadata, err = next.HandleDeserialize(ctx, in) 4011 if err != nil { 4012 return out, metadata, err 4013 } 4014 4015 response, ok := out.RawResponse.(*smithyhttp.Response) 4016 if !ok { 4017 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4018 } 4019 4020 if response.StatusCode < 200 || response.StatusCode >= 300 { 4021 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 4022 } 4023 output := &ListTagsForResourceOutput{} 4024 out.Result = output 4025 4026 var buff [1024]byte 4027 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4028 4029 body := io.TeeReader(response.Body, ringBuffer) 4030 4031 decoder := json.NewDecoder(body) 4032 decoder.UseNumber() 4033 var shape interface{} 4034 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4035 var snapshot bytes.Buffer 4036 io.Copy(&snapshot, ringBuffer) 4037 err = &smithy.DeserializationError{ 4038 Err: fmt.Errorf("failed to decode response body, %w", err), 4039 Snapshot: snapshot.Bytes(), 4040 } 4041 return out, metadata, err 4042 } 4043 4044 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 4045 if err != nil { 4046 var snapshot bytes.Buffer 4047 io.Copy(&snapshot, ringBuffer) 4048 return out, metadata, &smithy.DeserializationError{ 4049 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4050 Snapshot: snapshot.Bytes(), 4051 } 4052 } 4053 4054 return out, metadata, err 4055} 4056 4057func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4058 var errorBuffer bytes.Buffer 4059 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4060 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4061 } 4062 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4063 4064 errorCode := "UnknownError" 4065 errorMessage := errorCode 4066 4067 code := response.Header.Get("X-Amzn-ErrorType") 4068 if len(code) != 0 { 4069 errorCode = restjson.SanitizeErrorCode(code) 4070 } 4071 4072 var buff [1024]byte 4073 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4074 4075 body := io.TeeReader(errorBody, ringBuffer) 4076 decoder := json.NewDecoder(body) 4077 decoder.UseNumber() 4078 code, message, err := restjson.GetErrorInfo(decoder) 4079 if err != nil { 4080 var snapshot bytes.Buffer 4081 io.Copy(&snapshot, ringBuffer) 4082 err = &smithy.DeserializationError{ 4083 Err: fmt.Errorf("failed to decode response body, %w", err), 4084 Snapshot: snapshot.Bytes(), 4085 } 4086 return err 4087 } 4088 4089 errorBody.Seek(0, io.SeekStart) 4090 if len(code) != 0 { 4091 errorCode = restjson.SanitizeErrorCode(code) 4092 } 4093 if len(message) != 0 { 4094 errorMessage = message 4095 } 4096 4097 switch { 4098 case strings.EqualFold("BadRequestException", errorCode): 4099 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4100 4101 case strings.EqualFold("ForbiddenException", errorCode): 4102 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4103 4104 case strings.EqualFold("InternalServerErrorException", errorCode): 4105 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4106 4107 case strings.EqualFold("NotFoundException", errorCode): 4108 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4109 4110 case strings.EqualFold("ServiceUnavailableException", errorCode): 4111 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4112 4113 case strings.EqualFold("TooManyRequestsException", errorCode): 4114 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4115 4116 default: 4117 genericError := &smithy.GenericAPIError{ 4118 Code: errorCode, 4119 Message: errorMessage, 4120 } 4121 return genericError 4122 4123 } 4124} 4125 4126func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 4127 if v == nil { 4128 return fmt.Errorf("unexpected nil of type %T", v) 4129 } 4130 if value == nil { 4131 return nil 4132 } 4133 4134 shape, ok := value.(map[string]interface{}) 4135 if !ok { 4136 return fmt.Errorf("unexpected JSON type %v", value) 4137 } 4138 4139 var sv *ListTagsForResourceOutput 4140 if *v == nil { 4141 sv = &ListTagsForResourceOutput{} 4142 } else { 4143 sv = *v 4144 } 4145 4146 for key, value := range shape { 4147 switch key { 4148 case "nextToken": 4149 if value != nil { 4150 jtv, ok := value.(string) 4151 if !ok { 4152 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4153 } 4154 sv.NextToken = ptr.String(jtv) 4155 } 4156 4157 case "tags": 4158 if err := awsRestjson1_deserializeDocumentTagList(&sv.Tags, value); err != nil { 4159 return err 4160 } 4161 4162 default: 4163 _, _ = key, value 4164 4165 } 4166 } 4167 *v = sv 4168 return nil 4169} 4170 4171type awsRestjson1_deserializeOpListVirtualGateways struct { 4172} 4173 4174func (*awsRestjson1_deserializeOpListVirtualGateways) ID() string { 4175 return "OperationDeserializer" 4176} 4177 4178func (m *awsRestjson1_deserializeOpListVirtualGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4179 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4180) { 4181 out, metadata, err = next.HandleDeserialize(ctx, in) 4182 if err != nil { 4183 return out, metadata, err 4184 } 4185 4186 response, ok := out.RawResponse.(*smithyhttp.Response) 4187 if !ok { 4188 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4189 } 4190 4191 if response.StatusCode < 200 || response.StatusCode >= 300 { 4192 return out, metadata, awsRestjson1_deserializeOpErrorListVirtualGateways(response, &metadata) 4193 } 4194 output := &ListVirtualGatewaysOutput{} 4195 out.Result = output 4196 4197 var buff [1024]byte 4198 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4199 4200 body := io.TeeReader(response.Body, ringBuffer) 4201 4202 decoder := json.NewDecoder(body) 4203 decoder.UseNumber() 4204 var shape interface{} 4205 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4206 var snapshot bytes.Buffer 4207 io.Copy(&snapshot, ringBuffer) 4208 err = &smithy.DeserializationError{ 4209 Err: fmt.Errorf("failed to decode response body, %w", err), 4210 Snapshot: snapshot.Bytes(), 4211 } 4212 return out, metadata, err 4213 } 4214 4215 err = awsRestjson1_deserializeOpDocumentListVirtualGatewaysOutput(&output, shape) 4216 if err != nil { 4217 var snapshot bytes.Buffer 4218 io.Copy(&snapshot, ringBuffer) 4219 return out, metadata, &smithy.DeserializationError{ 4220 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4221 Snapshot: snapshot.Bytes(), 4222 } 4223 } 4224 4225 return out, metadata, err 4226} 4227 4228func awsRestjson1_deserializeOpErrorListVirtualGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4229 var errorBuffer bytes.Buffer 4230 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4231 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4232 } 4233 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4234 4235 errorCode := "UnknownError" 4236 errorMessage := errorCode 4237 4238 code := response.Header.Get("X-Amzn-ErrorType") 4239 if len(code) != 0 { 4240 errorCode = restjson.SanitizeErrorCode(code) 4241 } 4242 4243 var buff [1024]byte 4244 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4245 4246 body := io.TeeReader(errorBody, ringBuffer) 4247 decoder := json.NewDecoder(body) 4248 decoder.UseNumber() 4249 code, message, err := restjson.GetErrorInfo(decoder) 4250 if err != nil { 4251 var snapshot bytes.Buffer 4252 io.Copy(&snapshot, ringBuffer) 4253 err = &smithy.DeserializationError{ 4254 Err: fmt.Errorf("failed to decode response body, %w", err), 4255 Snapshot: snapshot.Bytes(), 4256 } 4257 return err 4258 } 4259 4260 errorBody.Seek(0, io.SeekStart) 4261 if len(code) != 0 { 4262 errorCode = restjson.SanitizeErrorCode(code) 4263 } 4264 if len(message) != 0 { 4265 errorMessage = message 4266 } 4267 4268 switch { 4269 case strings.EqualFold("BadRequestException", errorCode): 4270 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4271 4272 case strings.EqualFold("ForbiddenException", errorCode): 4273 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4274 4275 case strings.EqualFold("InternalServerErrorException", errorCode): 4276 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4277 4278 case strings.EqualFold("NotFoundException", errorCode): 4279 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4280 4281 case strings.EqualFold("ServiceUnavailableException", errorCode): 4282 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4283 4284 case strings.EqualFold("TooManyRequestsException", errorCode): 4285 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4286 4287 default: 4288 genericError := &smithy.GenericAPIError{ 4289 Code: errorCode, 4290 Message: errorMessage, 4291 } 4292 return genericError 4293 4294 } 4295} 4296 4297func awsRestjson1_deserializeOpDocumentListVirtualGatewaysOutput(v **ListVirtualGatewaysOutput, value interface{}) error { 4298 if v == nil { 4299 return fmt.Errorf("unexpected nil of type %T", v) 4300 } 4301 if value == nil { 4302 return nil 4303 } 4304 4305 shape, ok := value.(map[string]interface{}) 4306 if !ok { 4307 return fmt.Errorf("unexpected JSON type %v", value) 4308 } 4309 4310 var sv *ListVirtualGatewaysOutput 4311 if *v == nil { 4312 sv = &ListVirtualGatewaysOutput{} 4313 } else { 4314 sv = *v 4315 } 4316 4317 for key, value := range shape { 4318 switch key { 4319 case "nextToken": 4320 if value != nil { 4321 jtv, ok := value.(string) 4322 if !ok { 4323 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4324 } 4325 sv.NextToken = ptr.String(jtv) 4326 } 4327 4328 case "virtualGateways": 4329 if err := awsRestjson1_deserializeDocumentVirtualGatewayList(&sv.VirtualGateways, value); err != nil { 4330 return err 4331 } 4332 4333 default: 4334 _, _ = key, value 4335 4336 } 4337 } 4338 *v = sv 4339 return nil 4340} 4341 4342type awsRestjson1_deserializeOpListVirtualNodes struct { 4343} 4344 4345func (*awsRestjson1_deserializeOpListVirtualNodes) ID() string { 4346 return "OperationDeserializer" 4347} 4348 4349func (m *awsRestjson1_deserializeOpListVirtualNodes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4350 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4351) { 4352 out, metadata, err = next.HandleDeserialize(ctx, in) 4353 if err != nil { 4354 return out, metadata, err 4355 } 4356 4357 response, ok := out.RawResponse.(*smithyhttp.Response) 4358 if !ok { 4359 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4360 } 4361 4362 if response.StatusCode < 200 || response.StatusCode >= 300 { 4363 return out, metadata, awsRestjson1_deserializeOpErrorListVirtualNodes(response, &metadata) 4364 } 4365 output := &ListVirtualNodesOutput{} 4366 out.Result = output 4367 4368 var buff [1024]byte 4369 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4370 4371 body := io.TeeReader(response.Body, ringBuffer) 4372 4373 decoder := json.NewDecoder(body) 4374 decoder.UseNumber() 4375 var shape interface{} 4376 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4377 var snapshot bytes.Buffer 4378 io.Copy(&snapshot, ringBuffer) 4379 err = &smithy.DeserializationError{ 4380 Err: fmt.Errorf("failed to decode response body, %w", err), 4381 Snapshot: snapshot.Bytes(), 4382 } 4383 return out, metadata, err 4384 } 4385 4386 err = awsRestjson1_deserializeOpDocumentListVirtualNodesOutput(&output, shape) 4387 if err != nil { 4388 var snapshot bytes.Buffer 4389 io.Copy(&snapshot, ringBuffer) 4390 return out, metadata, &smithy.DeserializationError{ 4391 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4392 Snapshot: snapshot.Bytes(), 4393 } 4394 } 4395 4396 return out, metadata, err 4397} 4398 4399func awsRestjson1_deserializeOpErrorListVirtualNodes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4400 var errorBuffer bytes.Buffer 4401 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4402 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4403 } 4404 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4405 4406 errorCode := "UnknownError" 4407 errorMessage := errorCode 4408 4409 code := response.Header.Get("X-Amzn-ErrorType") 4410 if len(code) != 0 { 4411 errorCode = restjson.SanitizeErrorCode(code) 4412 } 4413 4414 var buff [1024]byte 4415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4416 4417 body := io.TeeReader(errorBody, ringBuffer) 4418 decoder := json.NewDecoder(body) 4419 decoder.UseNumber() 4420 code, message, err := restjson.GetErrorInfo(decoder) 4421 if err != nil { 4422 var snapshot bytes.Buffer 4423 io.Copy(&snapshot, ringBuffer) 4424 err = &smithy.DeserializationError{ 4425 Err: fmt.Errorf("failed to decode response body, %w", err), 4426 Snapshot: snapshot.Bytes(), 4427 } 4428 return err 4429 } 4430 4431 errorBody.Seek(0, io.SeekStart) 4432 if len(code) != 0 { 4433 errorCode = restjson.SanitizeErrorCode(code) 4434 } 4435 if len(message) != 0 { 4436 errorMessage = message 4437 } 4438 4439 switch { 4440 case strings.EqualFold("BadRequestException", errorCode): 4441 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4442 4443 case strings.EqualFold("ForbiddenException", errorCode): 4444 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4445 4446 case strings.EqualFold("InternalServerErrorException", errorCode): 4447 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4448 4449 case strings.EqualFold("NotFoundException", errorCode): 4450 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4451 4452 case strings.EqualFold("ServiceUnavailableException", errorCode): 4453 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4454 4455 case strings.EqualFold("TooManyRequestsException", errorCode): 4456 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4457 4458 default: 4459 genericError := &smithy.GenericAPIError{ 4460 Code: errorCode, 4461 Message: errorMessage, 4462 } 4463 return genericError 4464 4465 } 4466} 4467 4468func awsRestjson1_deserializeOpDocumentListVirtualNodesOutput(v **ListVirtualNodesOutput, value interface{}) error { 4469 if v == nil { 4470 return fmt.Errorf("unexpected nil of type %T", v) 4471 } 4472 if value == nil { 4473 return nil 4474 } 4475 4476 shape, ok := value.(map[string]interface{}) 4477 if !ok { 4478 return fmt.Errorf("unexpected JSON type %v", value) 4479 } 4480 4481 var sv *ListVirtualNodesOutput 4482 if *v == nil { 4483 sv = &ListVirtualNodesOutput{} 4484 } else { 4485 sv = *v 4486 } 4487 4488 for key, value := range shape { 4489 switch key { 4490 case "nextToken": 4491 if value != nil { 4492 jtv, ok := value.(string) 4493 if !ok { 4494 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4495 } 4496 sv.NextToken = ptr.String(jtv) 4497 } 4498 4499 case "virtualNodes": 4500 if err := awsRestjson1_deserializeDocumentVirtualNodeList(&sv.VirtualNodes, value); err != nil { 4501 return err 4502 } 4503 4504 default: 4505 _, _ = key, value 4506 4507 } 4508 } 4509 *v = sv 4510 return nil 4511} 4512 4513type awsRestjson1_deserializeOpListVirtualRouters struct { 4514} 4515 4516func (*awsRestjson1_deserializeOpListVirtualRouters) ID() string { 4517 return "OperationDeserializer" 4518} 4519 4520func (m *awsRestjson1_deserializeOpListVirtualRouters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4522) { 4523 out, metadata, err = next.HandleDeserialize(ctx, in) 4524 if err != nil { 4525 return out, metadata, err 4526 } 4527 4528 response, ok := out.RawResponse.(*smithyhttp.Response) 4529 if !ok { 4530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4531 } 4532 4533 if response.StatusCode < 200 || response.StatusCode >= 300 { 4534 return out, metadata, awsRestjson1_deserializeOpErrorListVirtualRouters(response, &metadata) 4535 } 4536 output := &ListVirtualRoutersOutput{} 4537 out.Result = output 4538 4539 var buff [1024]byte 4540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4541 4542 body := io.TeeReader(response.Body, ringBuffer) 4543 4544 decoder := json.NewDecoder(body) 4545 decoder.UseNumber() 4546 var shape interface{} 4547 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4548 var snapshot bytes.Buffer 4549 io.Copy(&snapshot, ringBuffer) 4550 err = &smithy.DeserializationError{ 4551 Err: fmt.Errorf("failed to decode response body, %w", err), 4552 Snapshot: snapshot.Bytes(), 4553 } 4554 return out, metadata, err 4555 } 4556 4557 err = awsRestjson1_deserializeOpDocumentListVirtualRoutersOutput(&output, shape) 4558 if err != nil { 4559 var snapshot bytes.Buffer 4560 io.Copy(&snapshot, ringBuffer) 4561 return out, metadata, &smithy.DeserializationError{ 4562 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4563 Snapshot: snapshot.Bytes(), 4564 } 4565 } 4566 4567 return out, metadata, err 4568} 4569 4570func awsRestjson1_deserializeOpErrorListVirtualRouters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4571 var errorBuffer bytes.Buffer 4572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4574 } 4575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4576 4577 errorCode := "UnknownError" 4578 errorMessage := errorCode 4579 4580 code := response.Header.Get("X-Amzn-ErrorType") 4581 if len(code) != 0 { 4582 errorCode = restjson.SanitizeErrorCode(code) 4583 } 4584 4585 var buff [1024]byte 4586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4587 4588 body := io.TeeReader(errorBody, ringBuffer) 4589 decoder := json.NewDecoder(body) 4590 decoder.UseNumber() 4591 code, message, err := restjson.GetErrorInfo(decoder) 4592 if err != nil { 4593 var snapshot bytes.Buffer 4594 io.Copy(&snapshot, ringBuffer) 4595 err = &smithy.DeserializationError{ 4596 Err: fmt.Errorf("failed to decode response body, %w", err), 4597 Snapshot: snapshot.Bytes(), 4598 } 4599 return err 4600 } 4601 4602 errorBody.Seek(0, io.SeekStart) 4603 if len(code) != 0 { 4604 errorCode = restjson.SanitizeErrorCode(code) 4605 } 4606 if len(message) != 0 { 4607 errorMessage = message 4608 } 4609 4610 switch { 4611 case strings.EqualFold("BadRequestException", errorCode): 4612 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4613 4614 case strings.EqualFold("ForbiddenException", errorCode): 4615 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4616 4617 case strings.EqualFold("InternalServerErrorException", errorCode): 4618 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4619 4620 case strings.EqualFold("NotFoundException", errorCode): 4621 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4622 4623 case strings.EqualFold("ServiceUnavailableException", errorCode): 4624 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4625 4626 case strings.EqualFold("TooManyRequestsException", errorCode): 4627 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4628 4629 default: 4630 genericError := &smithy.GenericAPIError{ 4631 Code: errorCode, 4632 Message: errorMessage, 4633 } 4634 return genericError 4635 4636 } 4637} 4638 4639func awsRestjson1_deserializeOpDocumentListVirtualRoutersOutput(v **ListVirtualRoutersOutput, value interface{}) error { 4640 if v == nil { 4641 return fmt.Errorf("unexpected nil of type %T", v) 4642 } 4643 if value == nil { 4644 return nil 4645 } 4646 4647 shape, ok := value.(map[string]interface{}) 4648 if !ok { 4649 return fmt.Errorf("unexpected JSON type %v", value) 4650 } 4651 4652 var sv *ListVirtualRoutersOutput 4653 if *v == nil { 4654 sv = &ListVirtualRoutersOutput{} 4655 } else { 4656 sv = *v 4657 } 4658 4659 for key, value := range shape { 4660 switch key { 4661 case "nextToken": 4662 if value != nil { 4663 jtv, ok := value.(string) 4664 if !ok { 4665 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4666 } 4667 sv.NextToken = ptr.String(jtv) 4668 } 4669 4670 case "virtualRouters": 4671 if err := awsRestjson1_deserializeDocumentVirtualRouterList(&sv.VirtualRouters, value); err != nil { 4672 return err 4673 } 4674 4675 default: 4676 _, _ = key, value 4677 4678 } 4679 } 4680 *v = sv 4681 return nil 4682} 4683 4684type awsRestjson1_deserializeOpListVirtualServices struct { 4685} 4686 4687func (*awsRestjson1_deserializeOpListVirtualServices) ID() string { 4688 return "OperationDeserializer" 4689} 4690 4691func (m *awsRestjson1_deserializeOpListVirtualServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4692 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4693) { 4694 out, metadata, err = next.HandleDeserialize(ctx, in) 4695 if err != nil { 4696 return out, metadata, err 4697 } 4698 4699 response, ok := out.RawResponse.(*smithyhttp.Response) 4700 if !ok { 4701 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4702 } 4703 4704 if response.StatusCode < 200 || response.StatusCode >= 300 { 4705 return out, metadata, awsRestjson1_deserializeOpErrorListVirtualServices(response, &metadata) 4706 } 4707 output := &ListVirtualServicesOutput{} 4708 out.Result = output 4709 4710 var buff [1024]byte 4711 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4712 4713 body := io.TeeReader(response.Body, ringBuffer) 4714 4715 decoder := json.NewDecoder(body) 4716 decoder.UseNumber() 4717 var shape interface{} 4718 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4719 var snapshot bytes.Buffer 4720 io.Copy(&snapshot, ringBuffer) 4721 err = &smithy.DeserializationError{ 4722 Err: fmt.Errorf("failed to decode response body, %w", err), 4723 Snapshot: snapshot.Bytes(), 4724 } 4725 return out, metadata, err 4726 } 4727 4728 err = awsRestjson1_deserializeOpDocumentListVirtualServicesOutput(&output, shape) 4729 if err != nil { 4730 var snapshot bytes.Buffer 4731 io.Copy(&snapshot, ringBuffer) 4732 return out, metadata, &smithy.DeserializationError{ 4733 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4734 Snapshot: snapshot.Bytes(), 4735 } 4736 } 4737 4738 return out, metadata, err 4739} 4740 4741func awsRestjson1_deserializeOpErrorListVirtualServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4742 var errorBuffer bytes.Buffer 4743 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4744 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4745 } 4746 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4747 4748 errorCode := "UnknownError" 4749 errorMessage := errorCode 4750 4751 code := response.Header.Get("X-Amzn-ErrorType") 4752 if len(code) != 0 { 4753 errorCode = restjson.SanitizeErrorCode(code) 4754 } 4755 4756 var buff [1024]byte 4757 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4758 4759 body := io.TeeReader(errorBody, ringBuffer) 4760 decoder := json.NewDecoder(body) 4761 decoder.UseNumber() 4762 code, message, err := restjson.GetErrorInfo(decoder) 4763 if err != nil { 4764 var snapshot bytes.Buffer 4765 io.Copy(&snapshot, ringBuffer) 4766 err = &smithy.DeserializationError{ 4767 Err: fmt.Errorf("failed to decode response body, %w", err), 4768 Snapshot: snapshot.Bytes(), 4769 } 4770 return err 4771 } 4772 4773 errorBody.Seek(0, io.SeekStart) 4774 if len(code) != 0 { 4775 errorCode = restjson.SanitizeErrorCode(code) 4776 } 4777 if len(message) != 0 { 4778 errorMessage = message 4779 } 4780 4781 switch { 4782 case strings.EqualFold("BadRequestException", errorCode): 4783 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4784 4785 case strings.EqualFold("ForbiddenException", errorCode): 4786 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4787 4788 case strings.EqualFold("InternalServerErrorException", errorCode): 4789 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4790 4791 case strings.EqualFold("NotFoundException", errorCode): 4792 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4793 4794 case strings.EqualFold("ServiceUnavailableException", errorCode): 4795 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4796 4797 case strings.EqualFold("TooManyRequestsException", errorCode): 4798 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4799 4800 default: 4801 genericError := &smithy.GenericAPIError{ 4802 Code: errorCode, 4803 Message: errorMessage, 4804 } 4805 return genericError 4806 4807 } 4808} 4809 4810func awsRestjson1_deserializeOpDocumentListVirtualServicesOutput(v **ListVirtualServicesOutput, value interface{}) error { 4811 if v == nil { 4812 return fmt.Errorf("unexpected nil of type %T", v) 4813 } 4814 if value == nil { 4815 return nil 4816 } 4817 4818 shape, ok := value.(map[string]interface{}) 4819 if !ok { 4820 return fmt.Errorf("unexpected JSON type %v", value) 4821 } 4822 4823 var sv *ListVirtualServicesOutput 4824 if *v == nil { 4825 sv = &ListVirtualServicesOutput{} 4826 } else { 4827 sv = *v 4828 } 4829 4830 for key, value := range shape { 4831 switch key { 4832 case "nextToken": 4833 if value != nil { 4834 jtv, ok := value.(string) 4835 if !ok { 4836 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4837 } 4838 sv.NextToken = ptr.String(jtv) 4839 } 4840 4841 case "virtualServices": 4842 if err := awsRestjson1_deserializeDocumentVirtualServiceList(&sv.VirtualServices, value); err != nil { 4843 return err 4844 } 4845 4846 default: 4847 _, _ = key, value 4848 4849 } 4850 } 4851 *v = sv 4852 return nil 4853} 4854 4855type awsRestjson1_deserializeOpTagResource struct { 4856} 4857 4858func (*awsRestjson1_deserializeOpTagResource) ID() string { 4859 return "OperationDeserializer" 4860} 4861 4862func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4863 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4864) { 4865 out, metadata, err = next.HandleDeserialize(ctx, in) 4866 if err != nil { 4867 return out, metadata, err 4868 } 4869 4870 response, ok := out.RawResponse.(*smithyhttp.Response) 4871 if !ok { 4872 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4873 } 4874 4875 if response.StatusCode < 200 || response.StatusCode >= 300 { 4876 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 4877 } 4878 output := &TagResourceOutput{} 4879 out.Result = output 4880 4881 return out, metadata, err 4882} 4883 4884func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4885 var errorBuffer bytes.Buffer 4886 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4887 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4888 } 4889 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4890 4891 errorCode := "UnknownError" 4892 errorMessage := errorCode 4893 4894 code := response.Header.Get("X-Amzn-ErrorType") 4895 if len(code) != 0 { 4896 errorCode = restjson.SanitizeErrorCode(code) 4897 } 4898 4899 var buff [1024]byte 4900 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4901 4902 body := io.TeeReader(errorBody, ringBuffer) 4903 decoder := json.NewDecoder(body) 4904 decoder.UseNumber() 4905 code, message, err := restjson.GetErrorInfo(decoder) 4906 if err != nil { 4907 var snapshot bytes.Buffer 4908 io.Copy(&snapshot, ringBuffer) 4909 err = &smithy.DeserializationError{ 4910 Err: fmt.Errorf("failed to decode response body, %w", err), 4911 Snapshot: snapshot.Bytes(), 4912 } 4913 return err 4914 } 4915 4916 errorBody.Seek(0, io.SeekStart) 4917 if len(code) != 0 { 4918 errorCode = restjson.SanitizeErrorCode(code) 4919 } 4920 if len(message) != 0 { 4921 errorMessage = message 4922 } 4923 4924 switch { 4925 case strings.EqualFold("BadRequestException", errorCode): 4926 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4927 4928 case strings.EqualFold("ForbiddenException", errorCode): 4929 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 4930 4931 case strings.EqualFold("InternalServerErrorException", errorCode): 4932 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4933 4934 case strings.EqualFold("NotFoundException", errorCode): 4935 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 4936 4937 case strings.EqualFold("ServiceUnavailableException", errorCode): 4938 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 4939 4940 case strings.EqualFold("TooManyRequestsException", errorCode): 4941 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 4942 4943 case strings.EqualFold("TooManyTagsException", errorCode): 4944 return awsRestjson1_deserializeErrorTooManyTagsException(response, errorBody) 4945 4946 default: 4947 genericError := &smithy.GenericAPIError{ 4948 Code: errorCode, 4949 Message: errorMessage, 4950 } 4951 return genericError 4952 4953 } 4954} 4955 4956type awsRestjson1_deserializeOpUntagResource struct { 4957} 4958 4959func (*awsRestjson1_deserializeOpUntagResource) ID() string { 4960 return "OperationDeserializer" 4961} 4962 4963func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4964 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4965) { 4966 out, metadata, err = next.HandleDeserialize(ctx, in) 4967 if err != nil { 4968 return out, metadata, err 4969 } 4970 4971 response, ok := out.RawResponse.(*smithyhttp.Response) 4972 if !ok { 4973 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4974 } 4975 4976 if response.StatusCode < 200 || response.StatusCode >= 300 { 4977 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 4978 } 4979 output := &UntagResourceOutput{} 4980 out.Result = output 4981 4982 return out, metadata, err 4983} 4984 4985func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4986 var errorBuffer bytes.Buffer 4987 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4988 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4989 } 4990 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4991 4992 errorCode := "UnknownError" 4993 errorMessage := errorCode 4994 4995 code := response.Header.Get("X-Amzn-ErrorType") 4996 if len(code) != 0 { 4997 errorCode = restjson.SanitizeErrorCode(code) 4998 } 4999 5000 var buff [1024]byte 5001 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5002 5003 body := io.TeeReader(errorBody, ringBuffer) 5004 decoder := json.NewDecoder(body) 5005 decoder.UseNumber() 5006 code, message, err := restjson.GetErrorInfo(decoder) 5007 if err != nil { 5008 var snapshot bytes.Buffer 5009 io.Copy(&snapshot, ringBuffer) 5010 err = &smithy.DeserializationError{ 5011 Err: fmt.Errorf("failed to decode response body, %w", err), 5012 Snapshot: snapshot.Bytes(), 5013 } 5014 return err 5015 } 5016 5017 errorBody.Seek(0, io.SeekStart) 5018 if len(code) != 0 { 5019 errorCode = restjson.SanitizeErrorCode(code) 5020 } 5021 if len(message) != 0 { 5022 errorMessage = message 5023 } 5024 5025 switch { 5026 case strings.EqualFold("BadRequestException", errorCode): 5027 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5028 5029 case strings.EqualFold("ForbiddenException", errorCode): 5030 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5031 5032 case strings.EqualFold("InternalServerErrorException", errorCode): 5033 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5034 5035 case strings.EqualFold("NotFoundException", errorCode): 5036 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5037 5038 case strings.EqualFold("ServiceUnavailableException", errorCode): 5039 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5040 5041 case strings.EqualFold("TooManyRequestsException", errorCode): 5042 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5043 5044 default: 5045 genericError := &smithy.GenericAPIError{ 5046 Code: errorCode, 5047 Message: errorMessage, 5048 } 5049 return genericError 5050 5051 } 5052} 5053 5054type awsRestjson1_deserializeOpUpdateGatewayRoute struct { 5055} 5056 5057func (*awsRestjson1_deserializeOpUpdateGatewayRoute) ID() string { 5058 return "OperationDeserializer" 5059} 5060 5061func (m *awsRestjson1_deserializeOpUpdateGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5062 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5063) { 5064 out, metadata, err = next.HandleDeserialize(ctx, in) 5065 if err != nil { 5066 return out, metadata, err 5067 } 5068 5069 response, ok := out.RawResponse.(*smithyhttp.Response) 5070 if !ok { 5071 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5072 } 5073 5074 if response.StatusCode < 200 || response.StatusCode >= 300 { 5075 return out, metadata, awsRestjson1_deserializeOpErrorUpdateGatewayRoute(response, &metadata) 5076 } 5077 output := &UpdateGatewayRouteOutput{} 5078 out.Result = output 5079 5080 var buff [1024]byte 5081 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5082 5083 body := io.TeeReader(response.Body, ringBuffer) 5084 5085 decoder := json.NewDecoder(body) 5086 decoder.UseNumber() 5087 var shape interface{} 5088 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5089 var snapshot bytes.Buffer 5090 io.Copy(&snapshot, ringBuffer) 5091 err = &smithy.DeserializationError{ 5092 Err: fmt.Errorf("failed to decode response body, %w", err), 5093 Snapshot: snapshot.Bytes(), 5094 } 5095 return out, metadata, err 5096 } 5097 5098 err = awsRestjson1_deserializeDocumentGatewayRouteData(&output.GatewayRoute, shape) 5099 if err != nil { 5100 var snapshot bytes.Buffer 5101 io.Copy(&snapshot, ringBuffer) 5102 return out, metadata, &smithy.DeserializationError{ 5103 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5104 Snapshot: snapshot.Bytes(), 5105 } 5106 } 5107 5108 return out, metadata, err 5109} 5110 5111func awsRestjson1_deserializeOpErrorUpdateGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5112 var errorBuffer bytes.Buffer 5113 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5114 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5115 } 5116 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5117 5118 errorCode := "UnknownError" 5119 errorMessage := errorCode 5120 5121 code := response.Header.Get("X-Amzn-ErrorType") 5122 if len(code) != 0 { 5123 errorCode = restjson.SanitizeErrorCode(code) 5124 } 5125 5126 var buff [1024]byte 5127 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5128 5129 body := io.TeeReader(errorBody, ringBuffer) 5130 decoder := json.NewDecoder(body) 5131 decoder.UseNumber() 5132 code, message, err := restjson.GetErrorInfo(decoder) 5133 if err != nil { 5134 var snapshot bytes.Buffer 5135 io.Copy(&snapshot, ringBuffer) 5136 err = &smithy.DeserializationError{ 5137 Err: fmt.Errorf("failed to decode response body, %w", err), 5138 Snapshot: snapshot.Bytes(), 5139 } 5140 return err 5141 } 5142 5143 errorBody.Seek(0, io.SeekStart) 5144 if len(code) != 0 { 5145 errorCode = restjson.SanitizeErrorCode(code) 5146 } 5147 if len(message) != 0 { 5148 errorMessage = message 5149 } 5150 5151 switch { 5152 case strings.EqualFold("BadRequestException", errorCode): 5153 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5154 5155 case strings.EqualFold("ConflictException", errorCode): 5156 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5157 5158 case strings.EqualFold("ForbiddenException", errorCode): 5159 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5160 5161 case strings.EqualFold("InternalServerErrorException", errorCode): 5162 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5163 5164 case strings.EqualFold("LimitExceededException", errorCode): 5165 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5166 5167 case strings.EqualFold("NotFoundException", errorCode): 5168 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5169 5170 case strings.EqualFold("ServiceUnavailableException", errorCode): 5171 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5172 5173 case strings.EqualFold("TooManyRequestsException", errorCode): 5174 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5175 5176 default: 5177 genericError := &smithy.GenericAPIError{ 5178 Code: errorCode, 5179 Message: errorMessage, 5180 } 5181 return genericError 5182 5183 } 5184} 5185 5186func awsRestjson1_deserializeOpDocumentUpdateGatewayRouteOutput(v **UpdateGatewayRouteOutput, value interface{}) error { 5187 if v == nil { 5188 return fmt.Errorf("unexpected nil of type %T", v) 5189 } 5190 if value == nil { 5191 return nil 5192 } 5193 5194 shape, ok := value.(map[string]interface{}) 5195 if !ok { 5196 return fmt.Errorf("unexpected JSON type %v", value) 5197 } 5198 5199 var sv *UpdateGatewayRouteOutput 5200 if *v == nil { 5201 sv = &UpdateGatewayRouteOutput{} 5202 } else { 5203 sv = *v 5204 } 5205 5206 for key, value := range shape { 5207 switch key { 5208 case "gatewayRoute": 5209 if err := awsRestjson1_deserializeDocumentGatewayRouteData(&sv.GatewayRoute, value); err != nil { 5210 return err 5211 } 5212 5213 default: 5214 _, _ = key, value 5215 5216 } 5217 } 5218 *v = sv 5219 return nil 5220} 5221 5222type awsRestjson1_deserializeOpUpdateMesh struct { 5223} 5224 5225func (*awsRestjson1_deserializeOpUpdateMesh) ID() string { 5226 return "OperationDeserializer" 5227} 5228 5229func (m *awsRestjson1_deserializeOpUpdateMesh) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5230 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5231) { 5232 out, metadata, err = next.HandleDeserialize(ctx, in) 5233 if err != nil { 5234 return out, metadata, err 5235 } 5236 5237 response, ok := out.RawResponse.(*smithyhttp.Response) 5238 if !ok { 5239 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5240 } 5241 5242 if response.StatusCode < 200 || response.StatusCode >= 300 { 5243 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMesh(response, &metadata) 5244 } 5245 output := &UpdateMeshOutput{} 5246 out.Result = output 5247 5248 var buff [1024]byte 5249 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5250 5251 body := io.TeeReader(response.Body, ringBuffer) 5252 5253 decoder := json.NewDecoder(body) 5254 decoder.UseNumber() 5255 var shape interface{} 5256 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5257 var snapshot bytes.Buffer 5258 io.Copy(&snapshot, ringBuffer) 5259 err = &smithy.DeserializationError{ 5260 Err: fmt.Errorf("failed to decode response body, %w", err), 5261 Snapshot: snapshot.Bytes(), 5262 } 5263 return out, metadata, err 5264 } 5265 5266 err = awsRestjson1_deserializeDocumentMeshData(&output.Mesh, shape) 5267 if err != nil { 5268 var snapshot bytes.Buffer 5269 io.Copy(&snapshot, ringBuffer) 5270 return out, metadata, &smithy.DeserializationError{ 5271 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5272 Snapshot: snapshot.Bytes(), 5273 } 5274 } 5275 5276 return out, metadata, err 5277} 5278 5279func awsRestjson1_deserializeOpErrorUpdateMesh(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5280 var errorBuffer bytes.Buffer 5281 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5282 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5283 } 5284 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5285 5286 errorCode := "UnknownError" 5287 errorMessage := errorCode 5288 5289 code := response.Header.Get("X-Amzn-ErrorType") 5290 if len(code) != 0 { 5291 errorCode = restjson.SanitizeErrorCode(code) 5292 } 5293 5294 var buff [1024]byte 5295 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5296 5297 body := io.TeeReader(errorBody, ringBuffer) 5298 decoder := json.NewDecoder(body) 5299 decoder.UseNumber() 5300 code, message, err := restjson.GetErrorInfo(decoder) 5301 if err != nil { 5302 var snapshot bytes.Buffer 5303 io.Copy(&snapshot, ringBuffer) 5304 err = &smithy.DeserializationError{ 5305 Err: fmt.Errorf("failed to decode response body, %w", err), 5306 Snapshot: snapshot.Bytes(), 5307 } 5308 return err 5309 } 5310 5311 errorBody.Seek(0, io.SeekStart) 5312 if len(code) != 0 { 5313 errorCode = restjson.SanitizeErrorCode(code) 5314 } 5315 if len(message) != 0 { 5316 errorMessage = message 5317 } 5318 5319 switch { 5320 case strings.EqualFold("BadRequestException", errorCode): 5321 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5322 5323 case strings.EqualFold("ConflictException", errorCode): 5324 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5325 5326 case strings.EqualFold("ForbiddenException", errorCode): 5327 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5328 5329 case strings.EqualFold("InternalServerErrorException", errorCode): 5330 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5331 5332 case strings.EqualFold("NotFoundException", errorCode): 5333 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5334 5335 case strings.EqualFold("ServiceUnavailableException", errorCode): 5336 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5337 5338 case strings.EqualFold("TooManyRequestsException", errorCode): 5339 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5340 5341 default: 5342 genericError := &smithy.GenericAPIError{ 5343 Code: errorCode, 5344 Message: errorMessage, 5345 } 5346 return genericError 5347 5348 } 5349} 5350 5351func awsRestjson1_deserializeOpDocumentUpdateMeshOutput(v **UpdateMeshOutput, value interface{}) error { 5352 if v == nil { 5353 return fmt.Errorf("unexpected nil of type %T", v) 5354 } 5355 if value == nil { 5356 return nil 5357 } 5358 5359 shape, ok := value.(map[string]interface{}) 5360 if !ok { 5361 return fmt.Errorf("unexpected JSON type %v", value) 5362 } 5363 5364 var sv *UpdateMeshOutput 5365 if *v == nil { 5366 sv = &UpdateMeshOutput{} 5367 } else { 5368 sv = *v 5369 } 5370 5371 for key, value := range shape { 5372 switch key { 5373 case "mesh": 5374 if err := awsRestjson1_deserializeDocumentMeshData(&sv.Mesh, value); err != nil { 5375 return err 5376 } 5377 5378 default: 5379 _, _ = key, value 5380 5381 } 5382 } 5383 *v = sv 5384 return nil 5385} 5386 5387type awsRestjson1_deserializeOpUpdateRoute struct { 5388} 5389 5390func (*awsRestjson1_deserializeOpUpdateRoute) ID() string { 5391 return "OperationDeserializer" 5392} 5393 5394func (m *awsRestjson1_deserializeOpUpdateRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5395 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5396) { 5397 out, metadata, err = next.HandleDeserialize(ctx, in) 5398 if err != nil { 5399 return out, metadata, err 5400 } 5401 5402 response, ok := out.RawResponse.(*smithyhttp.Response) 5403 if !ok { 5404 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5405 } 5406 5407 if response.StatusCode < 200 || response.StatusCode >= 300 { 5408 return out, metadata, awsRestjson1_deserializeOpErrorUpdateRoute(response, &metadata) 5409 } 5410 output := &UpdateRouteOutput{} 5411 out.Result = output 5412 5413 var buff [1024]byte 5414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5415 5416 body := io.TeeReader(response.Body, ringBuffer) 5417 5418 decoder := json.NewDecoder(body) 5419 decoder.UseNumber() 5420 var shape interface{} 5421 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5422 var snapshot bytes.Buffer 5423 io.Copy(&snapshot, ringBuffer) 5424 err = &smithy.DeserializationError{ 5425 Err: fmt.Errorf("failed to decode response body, %w", err), 5426 Snapshot: snapshot.Bytes(), 5427 } 5428 return out, metadata, err 5429 } 5430 5431 err = awsRestjson1_deserializeDocumentRouteData(&output.Route, shape) 5432 if err != nil { 5433 var snapshot bytes.Buffer 5434 io.Copy(&snapshot, ringBuffer) 5435 return out, metadata, &smithy.DeserializationError{ 5436 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5437 Snapshot: snapshot.Bytes(), 5438 } 5439 } 5440 5441 return out, metadata, err 5442} 5443 5444func awsRestjson1_deserializeOpErrorUpdateRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5445 var errorBuffer bytes.Buffer 5446 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5447 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5448 } 5449 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5450 5451 errorCode := "UnknownError" 5452 errorMessage := errorCode 5453 5454 code := response.Header.Get("X-Amzn-ErrorType") 5455 if len(code) != 0 { 5456 errorCode = restjson.SanitizeErrorCode(code) 5457 } 5458 5459 var buff [1024]byte 5460 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5461 5462 body := io.TeeReader(errorBody, ringBuffer) 5463 decoder := json.NewDecoder(body) 5464 decoder.UseNumber() 5465 code, message, err := restjson.GetErrorInfo(decoder) 5466 if err != nil { 5467 var snapshot bytes.Buffer 5468 io.Copy(&snapshot, ringBuffer) 5469 err = &smithy.DeserializationError{ 5470 Err: fmt.Errorf("failed to decode response body, %w", err), 5471 Snapshot: snapshot.Bytes(), 5472 } 5473 return err 5474 } 5475 5476 errorBody.Seek(0, io.SeekStart) 5477 if len(code) != 0 { 5478 errorCode = restjson.SanitizeErrorCode(code) 5479 } 5480 if len(message) != 0 { 5481 errorMessage = message 5482 } 5483 5484 switch { 5485 case strings.EqualFold("BadRequestException", errorCode): 5486 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5487 5488 case strings.EqualFold("ConflictException", errorCode): 5489 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5490 5491 case strings.EqualFold("ForbiddenException", errorCode): 5492 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5493 5494 case strings.EqualFold("InternalServerErrorException", errorCode): 5495 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5496 5497 case strings.EqualFold("LimitExceededException", errorCode): 5498 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5499 5500 case strings.EqualFold("NotFoundException", errorCode): 5501 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5502 5503 case strings.EqualFold("ServiceUnavailableException", errorCode): 5504 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5505 5506 case strings.EqualFold("TooManyRequestsException", errorCode): 5507 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5508 5509 default: 5510 genericError := &smithy.GenericAPIError{ 5511 Code: errorCode, 5512 Message: errorMessage, 5513 } 5514 return genericError 5515 5516 } 5517} 5518 5519func awsRestjson1_deserializeOpDocumentUpdateRouteOutput(v **UpdateRouteOutput, value interface{}) error { 5520 if v == nil { 5521 return fmt.Errorf("unexpected nil of type %T", v) 5522 } 5523 if value == nil { 5524 return nil 5525 } 5526 5527 shape, ok := value.(map[string]interface{}) 5528 if !ok { 5529 return fmt.Errorf("unexpected JSON type %v", value) 5530 } 5531 5532 var sv *UpdateRouteOutput 5533 if *v == nil { 5534 sv = &UpdateRouteOutput{} 5535 } else { 5536 sv = *v 5537 } 5538 5539 for key, value := range shape { 5540 switch key { 5541 case "route": 5542 if err := awsRestjson1_deserializeDocumentRouteData(&sv.Route, value); err != nil { 5543 return err 5544 } 5545 5546 default: 5547 _, _ = key, value 5548 5549 } 5550 } 5551 *v = sv 5552 return nil 5553} 5554 5555type awsRestjson1_deserializeOpUpdateVirtualGateway struct { 5556} 5557 5558func (*awsRestjson1_deserializeOpUpdateVirtualGateway) ID() string { 5559 return "OperationDeserializer" 5560} 5561 5562func (m *awsRestjson1_deserializeOpUpdateVirtualGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5563 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5564) { 5565 out, metadata, err = next.HandleDeserialize(ctx, in) 5566 if err != nil { 5567 return out, metadata, err 5568 } 5569 5570 response, ok := out.RawResponse.(*smithyhttp.Response) 5571 if !ok { 5572 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5573 } 5574 5575 if response.StatusCode < 200 || response.StatusCode >= 300 { 5576 return out, metadata, awsRestjson1_deserializeOpErrorUpdateVirtualGateway(response, &metadata) 5577 } 5578 output := &UpdateVirtualGatewayOutput{} 5579 out.Result = output 5580 5581 var buff [1024]byte 5582 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5583 5584 body := io.TeeReader(response.Body, ringBuffer) 5585 5586 decoder := json.NewDecoder(body) 5587 decoder.UseNumber() 5588 var shape interface{} 5589 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5590 var snapshot bytes.Buffer 5591 io.Copy(&snapshot, ringBuffer) 5592 err = &smithy.DeserializationError{ 5593 Err: fmt.Errorf("failed to decode response body, %w", err), 5594 Snapshot: snapshot.Bytes(), 5595 } 5596 return out, metadata, err 5597 } 5598 5599 err = awsRestjson1_deserializeDocumentVirtualGatewayData(&output.VirtualGateway, shape) 5600 if err != nil { 5601 var snapshot bytes.Buffer 5602 io.Copy(&snapshot, ringBuffer) 5603 return out, metadata, &smithy.DeserializationError{ 5604 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5605 Snapshot: snapshot.Bytes(), 5606 } 5607 } 5608 5609 return out, metadata, err 5610} 5611 5612func awsRestjson1_deserializeOpErrorUpdateVirtualGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5613 var errorBuffer bytes.Buffer 5614 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5615 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5616 } 5617 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5618 5619 errorCode := "UnknownError" 5620 errorMessage := errorCode 5621 5622 code := response.Header.Get("X-Amzn-ErrorType") 5623 if len(code) != 0 { 5624 errorCode = restjson.SanitizeErrorCode(code) 5625 } 5626 5627 var buff [1024]byte 5628 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5629 5630 body := io.TeeReader(errorBody, ringBuffer) 5631 decoder := json.NewDecoder(body) 5632 decoder.UseNumber() 5633 code, message, err := restjson.GetErrorInfo(decoder) 5634 if err != nil { 5635 var snapshot bytes.Buffer 5636 io.Copy(&snapshot, ringBuffer) 5637 err = &smithy.DeserializationError{ 5638 Err: fmt.Errorf("failed to decode response body, %w", err), 5639 Snapshot: snapshot.Bytes(), 5640 } 5641 return err 5642 } 5643 5644 errorBody.Seek(0, io.SeekStart) 5645 if len(code) != 0 { 5646 errorCode = restjson.SanitizeErrorCode(code) 5647 } 5648 if len(message) != 0 { 5649 errorMessage = message 5650 } 5651 5652 switch { 5653 case strings.EqualFold("BadRequestException", errorCode): 5654 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5655 5656 case strings.EqualFold("ConflictException", errorCode): 5657 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5658 5659 case strings.EqualFold("ForbiddenException", errorCode): 5660 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5661 5662 case strings.EqualFold("InternalServerErrorException", errorCode): 5663 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5664 5665 case strings.EqualFold("LimitExceededException", errorCode): 5666 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5667 5668 case strings.EqualFold("NotFoundException", errorCode): 5669 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5670 5671 case strings.EqualFold("ServiceUnavailableException", errorCode): 5672 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5673 5674 case strings.EqualFold("TooManyRequestsException", errorCode): 5675 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5676 5677 default: 5678 genericError := &smithy.GenericAPIError{ 5679 Code: errorCode, 5680 Message: errorMessage, 5681 } 5682 return genericError 5683 5684 } 5685} 5686 5687func awsRestjson1_deserializeOpDocumentUpdateVirtualGatewayOutput(v **UpdateVirtualGatewayOutput, value interface{}) error { 5688 if v == nil { 5689 return fmt.Errorf("unexpected nil of type %T", v) 5690 } 5691 if value == nil { 5692 return nil 5693 } 5694 5695 shape, ok := value.(map[string]interface{}) 5696 if !ok { 5697 return fmt.Errorf("unexpected JSON type %v", value) 5698 } 5699 5700 var sv *UpdateVirtualGatewayOutput 5701 if *v == nil { 5702 sv = &UpdateVirtualGatewayOutput{} 5703 } else { 5704 sv = *v 5705 } 5706 5707 for key, value := range shape { 5708 switch key { 5709 case "virtualGateway": 5710 if err := awsRestjson1_deserializeDocumentVirtualGatewayData(&sv.VirtualGateway, value); err != nil { 5711 return err 5712 } 5713 5714 default: 5715 _, _ = key, value 5716 5717 } 5718 } 5719 *v = sv 5720 return nil 5721} 5722 5723type awsRestjson1_deserializeOpUpdateVirtualNode struct { 5724} 5725 5726func (*awsRestjson1_deserializeOpUpdateVirtualNode) ID() string { 5727 return "OperationDeserializer" 5728} 5729 5730func (m *awsRestjson1_deserializeOpUpdateVirtualNode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5731 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5732) { 5733 out, metadata, err = next.HandleDeserialize(ctx, in) 5734 if err != nil { 5735 return out, metadata, err 5736 } 5737 5738 response, ok := out.RawResponse.(*smithyhttp.Response) 5739 if !ok { 5740 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5741 } 5742 5743 if response.StatusCode < 200 || response.StatusCode >= 300 { 5744 return out, metadata, awsRestjson1_deserializeOpErrorUpdateVirtualNode(response, &metadata) 5745 } 5746 output := &UpdateVirtualNodeOutput{} 5747 out.Result = output 5748 5749 var buff [1024]byte 5750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5751 5752 body := io.TeeReader(response.Body, ringBuffer) 5753 5754 decoder := json.NewDecoder(body) 5755 decoder.UseNumber() 5756 var shape interface{} 5757 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5758 var snapshot bytes.Buffer 5759 io.Copy(&snapshot, ringBuffer) 5760 err = &smithy.DeserializationError{ 5761 Err: fmt.Errorf("failed to decode response body, %w", err), 5762 Snapshot: snapshot.Bytes(), 5763 } 5764 return out, metadata, err 5765 } 5766 5767 err = awsRestjson1_deserializeDocumentVirtualNodeData(&output.VirtualNode, shape) 5768 if err != nil { 5769 var snapshot bytes.Buffer 5770 io.Copy(&snapshot, ringBuffer) 5771 return out, metadata, &smithy.DeserializationError{ 5772 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5773 Snapshot: snapshot.Bytes(), 5774 } 5775 } 5776 5777 return out, metadata, err 5778} 5779 5780func awsRestjson1_deserializeOpErrorUpdateVirtualNode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5781 var errorBuffer bytes.Buffer 5782 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5783 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5784 } 5785 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5786 5787 errorCode := "UnknownError" 5788 errorMessage := errorCode 5789 5790 code := response.Header.Get("X-Amzn-ErrorType") 5791 if len(code) != 0 { 5792 errorCode = restjson.SanitizeErrorCode(code) 5793 } 5794 5795 var buff [1024]byte 5796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5797 5798 body := io.TeeReader(errorBody, ringBuffer) 5799 decoder := json.NewDecoder(body) 5800 decoder.UseNumber() 5801 code, message, err := restjson.GetErrorInfo(decoder) 5802 if err != nil { 5803 var snapshot bytes.Buffer 5804 io.Copy(&snapshot, ringBuffer) 5805 err = &smithy.DeserializationError{ 5806 Err: fmt.Errorf("failed to decode response body, %w", err), 5807 Snapshot: snapshot.Bytes(), 5808 } 5809 return err 5810 } 5811 5812 errorBody.Seek(0, io.SeekStart) 5813 if len(code) != 0 { 5814 errorCode = restjson.SanitizeErrorCode(code) 5815 } 5816 if len(message) != 0 { 5817 errorMessage = message 5818 } 5819 5820 switch { 5821 case strings.EqualFold("BadRequestException", errorCode): 5822 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5823 5824 case strings.EqualFold("ConflictException", errorCode): 5825 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5826 5827 case strings.EqualFold("ForbiddenException", errorCode): 5828 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5829 5830 case strings.EqualFold("InternalServerErrorException", errorCode): 5831 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5832 5833 case strings.EqualFold("LimitExceededException", errorCode): 5834 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5835 5836 case strings.EqualFold("NotFoundException", errorCode): 5837 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 5838 5839 case strings.EqualFold("ServiceUnavailableException", errorCode): 5840 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 5841 5842 case strings.EqualFold("TooManyRequestsException", errorCode): 5843 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 5844 5845 default: 5846 genericError := &smithy.GenericAPIError{ 5847 Code: errorCode, 5848 Message: errorMessage, 5849 } 5850 return genericError 5851 5852 } 5853} 5854 5855func awsRestjson1_deserializeOpDocumentUpdateVirtualNodeOutput(v **UpdateVirtualNodeOutput, value interface{}) error { 5856 if v == nil { 5857 return fmt.Errorf("unexpected nil of type %T", v) 5858 } 5859 if value == nil { 5860 return nil 5861 } 5862 5863 shape, ok := value.(map[string]interface{}) 5864 if !ok { 5865 return fmt.Errorf("unexpected JSON type %v", value) 5866 } 5867 5868 var sv *UpdateVirtualNodeOutput 5869 if *v == nil { 5870 sv = &UpdateVirtualNodeOutput{} 5871 } else { 5872 sv = *v 5873 } 5874 5875 for key, value := range shape { 5876 switch key { 5877 case "virtualNode": 5878 if err := awsRestjson1_deserializeDocumentVirtualNodeData(&sv.VirtualNode, value); err != nil { 5879 return err 5880 } 5881 5882 default: 5883 _, _ = key, value 5884 5885 } 5886 } 5887 *v = sv 5888 return nil 5889} 5890 5891type awsRestjson1_deserializeOpUpdateVirtualRouter struct { 5892} 5893 5894func (*awsRestjson1_deserializeOpUpdateVirtualRouter) ID() string { 5895 return "OperationDeserializer" 5896} 5897 5898func (m *awsRestjson1_deserializeOpUpdateVirtualRouter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5899 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5900) { 5901 out, metadata, err = next.HandleDeserialize(ctx, in) 5902 if err != nil { 5903 return out, metadata, err 5904 } 5905 5906 response, ok := out.RawResponse.(*smithyhttp.Response) 5907 if !ok { 5908 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5909 } 5910 5911 if response.StatusCode < 200 || response.StatusCode >= 300 { 5912 return out, metadata, awsRestjson1_deserializeOpErrorUpdateVirtualRouter(response, &metadata) 5913 } 5914 output := &UpdateVirtualRouterOutput{} 5915 out.Result = output 5916 5917 var buff [1024]byte 5918 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5919 5920 body := io.TeeReader(response.Body, ringBuffer) 5921 5922 decoder := json.NewDecoder(body) 5923 decoder.UseNumber() 5924 var shape interface{} 5925 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5926 var snapshot bytes.Buffer 5927 io.Copy(&snapshot, ringBuffer) 5928 err = &smithy.DeserializationError{ 5929 Err: fmt.Errorf("failed to decode response body, %w", err), 5930 Snapshot: snapshot.Bytes(), 5931 } 5932 return out, metadata, err 5933 } 5934 5935 err = awsRestjson1_deserializeDocumentVirtualRouterData(&output.VirtualRouter, shape) 5936 if err != nil { 5937 var snapshot bytes.Buffer 5938 io.Copy(&snapshot, ringBuffer) 5939 return out, metadata, &smithy.DeserializationError{ 5940 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5941 Snapshot: snapshot.Bytes(), 5942 } 5943 } 5944 5945 return out, metadata, err 5946} 5947 5948func awsRestjson1_deserializeOpErrorUpdateVirtualRouter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5949 var errorBuffer bytes.Buffer 5950 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5951 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5952 } 5953 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5954 5955 errorCode := "UnknownError" 5956 errorMessage := errorCode 5957 5958 code := response.Header.Get("X-Amzn-ErrorType") 5959 if len(code) != 0 { 5960 errorCode = restjson.SanitizeErrorCode(code) 5961 } 5962 5963 var buff [1024]byte 5964 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5965 5966 body := io.TeeReader(errorBody, ringBuffer) 5967 decoder := json.NewDecoder(body) 5968 decoder.UseNumber() 5969 code, message, err := restjson.GetErrorInfo(decoder) 5970 if err != nil { 5971 var snapshot bytes.Buffer 5972 io.Copy(&snapshot, ringBuffer) 5973 err = &smithy.DeserializationError{ 5974 Err: fmt.Errorf("failed to decode response body, %w", err), 5975 Snapshot: snapshot.Bytes(), 5976 } 5977 return err 5978 } 5979 5980 errorBody.Seek(0, io.SeekStart) 5981 if len(code) != 0 { 5982 errorCode = restjson.SanitizeErrorCode(code) 5983 } 5984 if len(message) != 0 { 5985 errorMessage = message 5986 } 5987 5988 switch { 5989 case strings.EqualFold("BadRequestException", errorCode): 5990 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5991 5992 case strings.EqualFold("ConflictException", errorCode): 5993 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 5994 5995 case strings.EqualFold("ForbiddenException", errorCode): 5996 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 5997 5998 case strings.EqualFold("InternalServerErrorException", errorCode): 5999 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6000 6001 case strings.EqualFold("LimitExceededException", errorCode): 6002 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6003 6004 case strings.EqualFold("NotFoundException", errorCode): 6005 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 6006 6007 case strings.EqualFold("ServiceUnavailableException", errorCode): 6008 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 6009 6010 case strings.EqualFold("TooManyRequestsException", errorCode): 6011 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6012 6013 default: 6014 genericError := &smithy.GenericAPIError{ 6015 Code: errorCode, 6016 Message: errorMessage, 6017 } 6018 return genericError 6019 6020 } 6021} 6022 6023func awsRestjson1_deserializeOpDocumentUpdateVirtualRouterOutput(v **UpdateVirtualRouterOutput, value interface{}) error { 6024 if v == nil { 6025 return fmt.Errorf("unexpected nil of type %T", v) 6026 } 6027 if value == nil { 6028 return nil 6029 } 6030 6031 shape, ok := value.(map[string]interface{}) 6032 if !ok { 6033 return fmt.Errorf("unexpected JSON type %v", value) 6034 } 6035 6036 var sv *UpdateVirtualRouterOutput 6037 if *v == nil { 6038 sv = &UpdateVirtualRouterOutput{} 6039 } else { 6040 sv = *v 6041 } 6042 6043 for key, value := range shape { 6044 switch key { 6045 case "virtualRouter": 6046 if err := awsRestjson1_deserializeDocumentVirtualRouterData(&sv.VirtualRouter, value); err != nil { 6047 return err 6048 } 6049 6050 default: 6051 _, _ = key, value 6052 6053 } 6054 } 6055 *v = sv 6056 return nil 6057} 6058 6059type awsRestjson1_deserializeOpUpdateVirtualService struct { 6060} 6061 6062func (*awsRestjson1_deserializeOpUpdateVirtualService) ID() string { 6063 return "OperationDeserializer" 6064} 6065 6066func (m *awsRestjson1_deserializeOpUpdateVirtualService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6067 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6068) { 6069 out, metadata, err = next.HandleDeserialize(ctx, in) 6070 if err != nil { 6071 return out, metadata, err 6072 } 6073 6074 response, ok := out.RawResponse.(*smithyhttp.Response) 6075 if !ok { 6076 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6077 } 6078 6079 if response.StatusCode < 200 || response.StatusCode >= 300 { 6080 return out, metadata, awsRestjson1_deserializeOpErrorUpdateVirtualService(response, &metadata) 6081 } 6082 output := &UpdateVirtualServiceOutput{} 6083 out.Result = output 6084 6085 var buff [1024]byte 6086 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6087 6088 body := io.TeeReader(response.Body, ringBuffer) 6089 6090 decoder := json.NewDecoder(body) 6091 decoder.UseNumber() 6092 var shape interface{} 6093 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6094 var snapshot bytes.Buffer 6095 io.Copy(&snapshot, ringBuffer) 6096 err = &smithy.DeserializationError{ 6097 Err: fmt.Errorf("failed to decode response body, %w", err), 6098 Snapshot: snapshot.Bytes(), 6099 } 6100 return out, metadata, err 6101 } 6102 6103 err = awsRestjson1_deserializeDocumentVirtualServiceData(&output.VirtualService, shape) 6104 if err != nil { 6105 var snapshot bytes.Buffer 6106 io.Copy(&snapshot, ringBuffer) 6107 return out, metadata, &smithy.DeserializationError{ 6108 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6109 Snapshot: snapshot.Bytes(), 6110 } 6111 } 6112 6113 return out, metadata, err 6114} 6115 6116func awsRestjson1_deserializeOpErrorUpdateVirtualService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6117 var errorBuffer bytes.Buffer 6118 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6119 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6120 } 6121 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6122 6123 errorCode := "UnknownError" 6124 errorMessage := errorCode 6125 6126 code := response.Header.Get("X-Amzn-ErrorType") 6127 if len(code) != 0 { 6128 errorCode = restjson.SanitizeErrorCode(code) 6129 } 6130 6131 var buff [1024]byte 6132 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6133 6134 body := io.TeeReader(errorBody, ringBuffer) 6135 decoder := json.NewDecoder(body) 6136 decoder.UseNumber() 6137 code, message, err := restjson.GetErrorInfo(decoder) 6138 if err != nil { 6139 var snapshot bytes.Buffer 6140 io.Copy(&snapshot, ringBuffer) 6141 err = &smithy.DeserializationError{ 6142 Err: fmt.Errorf("failed to decode response body, %w", err), 6143 Snapshot: snapshot.Bytes(), 6144 } 6145 return err 6146 } 6147 6148 errorBody.Seek(0, io.SeekStart) 6149 if len(code) != 0 { 6150 errorCode = restjson.SanitizeErrorCode(code) 6151 } 6152 if len(message) != 0 { 6153 errorMessage = message 6154 } 6155 6156 switch { 6157 case strings.EqualFold("BadRequestException", errorCode): 6158 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6159 6160 case strings.EqualFold("ConflictException", errorCode): 6161 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 6162 6163 case strings.EqualFold("ForbiddenException", errorCode): 6164 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 6165 6166 case strings.EqualFold("InternalServerErrorException", errorCode): 6167 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6168 6169 case strings.EqualFold("LimitExceededException", errorCode): 6170 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6171 6172 case strings.EqualFold("NotFoundException", errorCode): 6173 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 6174 6175 case strings.EqualFold("ServiceUnavailableException", errorCode): 6176 return awsRestjson1_deserializeErrorServiceUnavailableException(response, errorBody) 6177 6178 case strings.EqualFold("TooManyRequestsException", errorCode): 6179 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody) 6180 6181 default: 6182 genericError := &smithy.GenericAPIError{ 6183 Code: errorCode, 6184 Message: errorMessage, 6185 } 6186 return genericError 6187 6188 } 6189} 6190 6191func awsRestjson1_deserializeOpDocumentUpdateVirtualServiceOutput(v **UpdateVirtualServiceOutput, value interface{}) error { 6192 if v == nil { 6193 return fmt.Errorf("unexpected nil of type %T", v) 6194 } 6195 if value == nil { 6196 return nil 6197 } 6198 6199 shape, ok := value.(map[string]interface{}) 6200 if !ok { 6201 return fmt.Errorf("unexpected JSON type %v", value) 6202 } 6203 6204 var sv *UpdateVirtualServiceOutput 6205 if *v == nil { 6206 sv = &UpdateVirtualServiceOutput{} 6207 } else { 6208 sv = *v 6209 } 6210 6211 for key, value := range shape { 6212 switch key { 6213 case "virtualService": 6214 if err := awsRestjson1_deserializeDocumentVirtualServiceData(&sv.VirtualService, value); err != nil { 6215 return err 6216 } 6217 6218 default: 6219 _, _ = key, value 6220 6221 } 6222 } 6223 *v = sv 6224 return nil 6225} 6226 6227func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6228 output := &types.BadRequestException{} 6229 var buff [1024]byte 6230 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6231 6232 body := io.TeeReader(errorBody, ringBuffer) 6233 decoder := json.NewDecoder(body) 6234 decoder.UseNumber() 6235 var shape interface{} 6236 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6237 var snapshot bytes.Buffer 6238 io.Copy(&snapshot, ringBuffer) 6239 err = &smithy.DeserializationError{ 6240 Err: fmt.Errorf("failed to decode response body, %w", err), 6241 Snapshot: snapshot.Bytes(), 6242 } 6243 return err 6244 } 6245 6246 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 6247 6248 if err != nil { 6249 var snapshot bytes.Buffer 6250 io.Copy(&snapshot, ringBuffer) 6251 err = &smithy.DeserializationError{ 6252 Err: fmt.Errorf("failed to decode response body, %w", err), 6253 Snapshot: snapshot.Bytes(), 6254 } 6255 return err 6256 } 6257 6258 errorBody.Seek(0, io.SeekStart) 6259 6260 return output 6261} 6262 6263func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6264 output := &types.ConflictException{} 6265 var buff [1024]byte 6266 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6267 6268 body := io.TeeReader(errorBody, ringBuffer) 6269 decoder := json.NewDecoder(body) 6270 decoder.UseNumber() 6271 var shape interface{} 6272 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6273 var snapshot bytes.Buffer 6274 io.Copy(&snapshot, ringBuffer) 6275 err = &smithy.DeserializationError{ 6276 Err: fmt.Errorf("failed to decode response body, %w", err), 6277 Snapshot: snapshot.Bytes(), 6278 } 6279 return err 6280 } 6281 6282 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 6283 6284 if err != nil { 6285 var snapshot bytes.Buffer 6286 io.Copy(&snapshot, ringBuffer) 6287 err = &smithy.DeserializationError{ 6288 Err: fmt.Errorf("failed to decode response body, %w", err), 6289 Snapshot: snapshot.Bytes(), 6290 } 6291 return err 6292 } 6293 6294 errorBody.Seek(0, io.SeekStart) 6295 6296 return output 6297} 6298 6299func awsRestjson1_deserializeErrorForbiddenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6300 output := &types.ForbiddenException{} 6301 var buff [1024]byte 6302 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6303 6304 body := io.TeeReader(errorBody, ringBuffer) 6305 decoder := json.NewDecoder(body) 6306 decoder.UseNumber() 6307 var shape interface{} 6308 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6309 var snapshot bytes.Buffer 6310 io.Copy(&snapshot, ringBuffer) 6311 err = &smithy.DeserializationError{ 6312 Err: fmt.Errorf("failed to decode response body, %w", err), 6313 Snapshot: snapshot.Bytes(), 6314 } 6315 return err 6316 } 6317 6318 err := awsRestjson1_deserializeDocumentForbiddenException(&output, shape) 6319 6320 if err != nil { 6321 var snapshot bytes.Buffer 6322 io.Copy(&snapshot, ringBuffer) 6323 err = &smithy.DeserializationError{ 6324 Err: fmt.Errorf("failed to decode response body, %w", err), 6325 Snapshot: snapshot.Bytes(), 6326 } 6327 return err 6328 } 6329 6330 errorBody.Seek(0, io.SeekStart) 6331 6332 return output 6333} 6334 6335func awsRestjson1_deserializeErrorInternalServerErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6336 output := &types.InternalServerErrorException{} 6337 var buff [1024]byte 6338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6339 6340 body := io.TeeReader(errorBody, ringBuffer) 6341 decoder := json.NewDecoder(body) 6342 decoder.UseNumber() 6343 var shape interface{} 6344 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6345 var snapshot bytes.Buffer 6346 io.Copy(&snapshot, ringBuffer) 6347 err = &smithy.DeserializationError{ 6348 Err: fmt.Errorf("failed to decode response body, %w", err), 6349 Snapshot: snapshot.Bytes(), 6350 } 6351 return err 6352 } 6353 6354 err := awsRestjson1_deserializeDocumentInternalServerErrorException(&output, shape) 6355 6356 if err != nil { 6357 var snapshot bytes.Buffer 6358 io.Copy(&snapshot, ringBuffer) 6359 err = &smithy.DeserializationError{ 6360 Err: fmt.Errorf("failed to decode response body, %w", err), 6361 Snapshot: snapshot.Bytes(), 6362 } 6363 return err 6364 } 6365 6366 errorBody.Seek(0, io.SeekStart) 6367 6368 return output 6369} 6370 6371func awsRestjson1_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6372 output := &types.LimitExceededException{} 6373 var buff [1024]byte 6374 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6375 6376 body := io.TeeReader(errorBody, ringBuffer) 6377 decoder := json.NewDecoder(body) 6378 decoder.UseNumber() 6379 var shape interface{} 6380 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6381 var snapshot bytes.Buffer 6382 io.Copy(&snapshot, ringBuffer) 6383 err = &smithy.DeserializationError{ 6384 Err: fmt.Errorf("failed to decode response body, %w", err), 6385 Snapshot: snapshot.Bytes(), 6386 } 6387 return err 6388 } 6389 6390 err := awsRestjson1_deserializeDocumentLimitExceededException(&output, shape) 6391 6392 if err != nil { 6393 var snapshot bytes.Buffer 6394 io.Copy(&snapshot, ringBuffer) 6395 err = &smithy.DeserializationError{ 6396 Err: fmt.Errorf("failed to decode response body, %w", err), 6397 Snapshot: snapshot.Bytes(), 6398 } 6399 return err 6400 } 6401 6402 errorBody.Seek(0, io.SeekStart) 6403 6404 return output 6405} 6406 6407func awsRestjson1_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6408 output := &types.NotFoundException{} 6409 var buff [1024]byte 6410 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6411 6412 body := io.TeeReader(errorBody, ringBuffer) 6413 decoder := json.NewDecoder(body) 6414 decoder.UseNumber() 6415 var shape interface{} 6416 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6417 var snapshot bytes.Buffer 6418 io.Copy(&snapshot, ringBuffer) 6419 err = &smithy.DeserializationError{ 6420 Err: fmt.Errorf("failed to decode response body, %w", err), 6421 Snapshot: snapshot.Bytes(), 6422 } 6423 return err 6424 } 6425 6426 err := awsRestjson1_deserializeDocumentNotFoundException(&output, shape) 6427 6428 if err != nil { 6429 var snapshot bytes.Buffer 6430 io.Copy(&snapshot, ringBuffer) 6431 err = &smithy.DeserializationError{ 6432 Err: fmt.Errorf("failed to decode response body, %w", err), 6433 Snapshot: snapshot.Bytes(), 6434 } 6435 return err 6436 } 6437 6438 errorBody.Seek(0, io.SeekStart) 6439 6440 return output 6441} 6442 6443func awsRestjson1_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6444 output := &types.ResourceInUseException{} 6445 var buff [1024]byte 6446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6447 6448 body := io.TeeReader(errorBody, ringBuffer) 6449 decoder := json.NewDecoder(body) 6450 decoder.UseNumber() 6451 var shape interface{} 6452 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6453 var snapshot bytes.Buffer 6454 io.Copy(&snapshot, ringBuffer) 6455 err = &smithy.DeserializationError{ 6456 Err: fmt.Errorf("failed to decode response body, %w", err), 6457 Snapshot: snapshot.Bytes(), 6458 } 6459 return err 6460 } 6461 6462 err := awsRestjson1_deserializeDocumentResourceInUseException(&output, shape) 6463 6464 if err != nil { 6465 var snapshot bytes.Buffer 6466 io.Copy(&snapshot, ringBuffer) 6467 err = &smithy.DeserializationError{ 6468 Err: fmt.Errorf("failed to decode response body, %w", err), 6469 Snapshot: snapshot.Bytes(), 6470 } 6471 return err 6472 } 6473 6474 errorBody.Seek(0, io.SeekStart) 6475 6476 return output 6477} 6478 6479func awsRestjson1_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6480 output := &types.ServiceUnavailableException{} 6481 var buff [1024]byte 6482 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6483 6484 body := io.TeeReader(errorBody, ringBuffer) 6485 decoder := json.NewDecoder(body) 6486 decoder.UseNumber() 6487 var shape interface{} 6488 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6489 var snapshot bytes.Buffer 6490 io.Copy(&snapshot, ringBuffer) 6491 err = &smithy.DeserializationError{ 6492 Err: fmt.Errorf("failed to decode response body, %w", err), 6493 Snapshot: snapshot.Bytes(), 6494 } 6495 return err 6496 } 6497 6498 err := awsRestjson1_deserializeDocumentServiceUnavailableException(&output, shape) 6499 6500 if err != nil { 6501 var snapshot bytes.Buffer 6502 io.Copy(&snapshot, ringBuffer) 6503 err = &smithy.DeserializationError{ 6504 Err: fmt.Errorf("failed to decode response body, %w", err), 6505 Snapshot: snapshot.Bytes(), 6506 } 6507 return err 6508 } 6509 6510 errorBody.Seek(0, io.SeekStart) 6511 6512 return output 6513} 6514 6515func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6516 output := &types.TooManyRequestsException{} 6517 var buff [1024]byte 6518 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6519 6520 body := io.TeeReader(errorBody, ringBuffer) 6521 decoder := json.NewDecoder(body) 6522 decoder.UseNumber() 6523 var shape interface{} 6524 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6525 var snapshot bytes.Buffer 6526 io.Copy(&snapshot, ringBuffer) 6527 err = &smithy.DeserializationError{ 6528 Err: fmt.Errorf("failed to decode response body, %w", err), 6529 Snapshot: snapshot.Bytes(), 6530 } 6531 return err 6532 } 6533 6534 err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape) 6535 6536 if err != nil { 6537 var snapshot bytes.Buffer 6538 io.Copy(&snapshot, ringBuffer) 6539 err = &smithy.DeserializationError{ 6540 Err: fmt.Errorf("failed to decode response body, %w", err), 6541 Snapshot: snapshot.Bytes(), 6542 } 6543 return err 6544 } 6545 6546 errorBody.Seek(0, io.SeekStart) 6547 6548 return output 6549} 6550 6551func awsRestjson1_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6552 output := &types.TooManyTagsException{} 6553 var buff [1024]byte 6554 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6555 6556 body := io.TeeReader(errorBody, ringBuffer) 6557 decoder := json.NewDecoder(body) 6558 decoder.UseNumber() 6559 var shape interface{} 6560 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6561 var snapshot bytes.Buffer 6562 io.Copy(&snapshot, ringBuffer) 6563 err = &smithy.DeserializationError{ 6564 Err: fmt.Errorf("failed to decode response body, %w", err), 6565 Snapshot: snapshot.Bytes(), 6566 } 6567 return err 6568 } 6569 6570 err := awsRestjson1_deserializeDocumentTooManyTagsException(&output, shape) 6571 6572 if err != nil { 6573 var snapshot bytes.Buffer 6574 io.Copy(&snapshot, ringBuffer) 6575 err = &smithy.DeserializationError{ 6576 Err: fmt.Errorf("failed to decode response body, %w", err), 6577 Snapshot: snapshot.Bytes(), 6578 } 6579 return err 6580 } 6581 6582 errorBody.Seek(0, io.SeekStart) 6583 6584 return output 6585} 6586 6587func awsRestjson1_deserializeDocumentAccessLog(v *types.AccessLog, value interface{}) error { 6588 if v == nil { 6589 return fmt.Errorf("unexpected nil of type %T", v) 6590 } 6591 if value == nil { 6592 return nil 6593 } 6594 6595 shape, ok := value.(map[string]interface{}) 6596 if !ok { 6597 return fmt.Errorf("unexpected JSON type %v", value) 6598 } 6599 6600 var uv types.AccessLog 6601loop: 6602 for key, value := range shape { 6603 if value == nil { 6604 continue 6605 } 6606 switch key { 6607 case "file": 6608 var mv types.FileAccessLog 6609 destAddr := &mv 6610 if err := awsRestjson1_deserializeDocumentFileAccessLog(&destAddr, value); err != nil { 6611 return err 6612 } 6613 mv = *destAddr 6614 uv = &types.AccessLogMemberFile{Value: mv} 6615 break loop 6616 6617 default: 6618 uv = &types.UnknownUnionMember{Tag: key} 6619 break loop 6620 6621 } 6622 } 6623 *v = uv 6624 return nil 6625} 6626 6627func awsRestjson1_deserializeDocumentAwsCloudMapInstanceAttribute(v **types.AwsCloudMapInstanceAttribute, value interface{}) error { 6628 if v == nil { 6629 return fmt.Errorf("unexpected nil of type %T", v) 6630 } 6631 if value == nil { 6632 return nil 6633 } 6634 6635 shape, ok := value.(map[string]interface{}) 6636 if !ok { 6637 return fmt.Errorf("unexpected JSON type %v", value) 6638 } 6639 6640 var sv *types.AwsCloudMapInstanceAttribute 6641 if *v == nil { 6642 sv = &types.AwsCloudMapInstanceAttribute{} 6643 } else { 6644 sv = *v 6645 } 6646 6647 for key, value := range shape { 6648 switch key { 6649 case "key": 6650 if value != nil { 6651 jtv, ok := value.(string) 6652 if !ok { 6653 return fmt.Errorf("expected AwsCloudMapInstanceAttributeKey to be of type string, got %T instead", value) 6654 } 6655 sv.Key = ptr.String(jtv) 6656 } 6657 6658 case "value": 6659 if value != nil { 6660 jtv, ok := value.(string) 6661 if !ok { 6662 return fmt.Errorf("expected AwsCloudMapInstanceAttributeValue to be of type string, got %T instead", value) 6663 } 6664 sv.Value = ptr.String(jtv) 6665 } 6666 6667 default: 6668 _, _ = key, value 6669 6670 } 6671 } 6672 *v = sv 6673 return nil 6674} 6675 6676func awsRestjson1_deserializeDocumentAwsCloudMapInstanceAttributes(v *[]types.AwsCloudMapInstanceAttribute, value interface{}) error { 6677 if v == nil { 6678 return fmt.Errorf("unexpected nil of type %T", v) 6679 } 6680 if value == nil { 6681 return nil 6682 } 6683 6684 shape, ok := value.([]interface{}) 6685 if !ok { 6686 return fmt.Errorf("unexpected JSON type %v", value) 6687 } 6688 6689 var cv []types.AwsCloudMapInstanceAttribute 6690 if *v == nil { 6691 cv = []types.AwsCloudMapInstanceAttribute{} 6692 } else { 6693 cv = *v 6694 } 6695 6696 for _, value := range shape { 6697 var col types.AwsCloudMapInstanceAttribute 6698 destAddr := &col 6699 if err := awsRestjson1_deserializeDocumentAwsCloudMapInstanceAttribute(&destAddr, value); err != nil { 6700 return err 6701 } 6702 col = *destAddr 6703 cv = append(cv, col) 6704 6705 } 6706 *v = cv 6707 return nil 6708} 6709 6710func awsRestjson1_deserializeDocumentAwsCloudMapServiceDiscovery(v **types.AwsCloudMapServiceDiscovery, value interface{}) error { 6711 if v == nil { 6712 return fmt.Errorf("unexpected nil of type %T", v) 6713 } 6714 if value == nil { 6715 return nil 6716 } 6717 6718 shape, ok := value.(map[string]interface{}) 6719 if !ok { 6720 return fmt.Errorf("unexpected JSON type %v", value) 6721 } 6722 6723 var sv *types.AwsCloudMapServiceDiscovery 6724 if *v == nil { 6725 sv = &types.AwsCloudMapServiceDiscovery{} 6726 } else { 6727 sv = *v 6728 } 6729 6730 for key, value := range shape { 6731 switch key { 6732 case "attributes": 6733 if err := awsRestjson1_deserializeDocumentAwsCloudMapInstanceAttributes(&sv.Attributes, value); err != nil { 6734 return err 6735 } 6736 6737 case "namespaceName": 6738 if value != nil { 6739 jtv, ok := value.(string) 6740 if !ok { 6741 return fmt.Errorf("expected AwsCloudMapName to be of type string, got %T instead", value) 6742 } 6743 sv.NamespaceName = ptr.String(jtv) 6744 } 6745 6746 case "serviceName": 6747 if value != nil { 6748 jtv, ok := value.(string) 6749 if !ok { 6750 return fmt.Errorf("expected AwsCloudMapName to be of type string, got %T instead", value) 6751 } 6752 sv.ServiceName = ptr.String(jtv) 6753 } 6754 6755 default: 6756 _, _ = key, value 6757 6758 } 6759 } 6760 *v = sv 6761 return nil 6762} 6763 6764func awsRestjson1_deserializeDocumentBackend(v *types.Backend, value interface{}) error { 6765 if v == nil { 6766 return fmt.Errorf("unexpected nil of type %T", v) 6767 } 6768 if value == nil { 6769 return nil 6770 } 6771 6772 shape, ok := value.(map[string]interface{}) 6773 if !ok { 6774 return fmt.Errorf("unexpected JSON type %v", value) 6775 } 6776 6777 var uv types.Backend 6778loop: 6779 for key, value := range shape { 6780 if value == nil { 6781 continue 6782 } 6783 switch key { 6784 case "virtualService": 6785 var mv types.VirtualServiceBackend 6786 destAddr := &mv 6787 if err := awsRestjson1_deserializeDocumentVirtualServiceBackend(&destAddr, value); err != nil { 6788 return err 6789 } 6790 mv = *destAddr 6791 uv = &types.BackendMemberVirtualService{Value: mv} 6792 break loop 6793 6794 default: 6795 uv = &types.UnknownUnionMember{Tag: key} 6796 break loop 6797 6798 } 6799 } 6800 *v = uv 6801 return nil 6802} 6803 6804func awsRestjson1_deserializeDocumentBackendDefaults(v **types.BackendDefaults, value interface{}) error { 6805 if v == nil { 6806 return fmt.Errorf("unexpected nil of type %T", v) 6807 } 6808 if value == nil { 6809 return nil 6810 } 6811 6812 shape, ok := value.(map[string]interface{}) 6813 if !ok { 6814 return fmt.Errorf("unexpected JSON type %v", value) 6815 } 6816 6817 var sv *types.BackendDefaults 6818 if *v == nil { 6819 sv = &types.BackendDefaults{} 6820 } else { 6821 sv = *v 6822 } 6823 6824 for key, value := range shape { 6825 switch key { 6826 case "clientPolicy": 6827 if err := awsRestjson1_deserializeDocumentClientPolicy(&sv.ClientPolicy, value); err != nil { 6828 return err 6829 } 6830 6831 default: 6832 _, _ = key, value 6833 6834 } 6835 } 6836 *v = sv 6837 return nil 6838} 6839 6840func awsRestjson1_deserializeDocumentBackends(v *[]types.Backend, value interface{}) error { 6841 if v == nil { 6842 return fmt.Errorf("unexpected nil of type %T", v) 6843 } 6844 if value == nil { 6845 return nil 6846 } 6847 6848 shape, ok := value.([]interface{}) 6849 if !ok { 6850 return fmt.Errorf("unexpected JSON type %v", value) 6851 } 6852 6853 var cv []types.Backend 6854 if *v == nil { 6855 cv = []types.Backend{} 6856 } else { 6857 cv = *v 6858 } 6859 6860 for _, value := range shape { 6861 var col types.Backend 6862 if err := awsRestjson1_deserializeDocumentBackend(&col, value); err != nil { 6863 return err 6864 } 6865 cv = append(cv, col) 6866 6867 } 6868 *v = cv 6869 return nil 6870} 6871 6872func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 6873 if v == nil { 6874 return fmt.Errorf("unexpected nil of type %T", v) 6875 } 6876 if value == nil { 6877 return nil 6878 } 6879 6880 shape, ok := value.(map[string]interface{}) 6881 if !ok { 6882 return fmt.Errorf("unexpected JSON type %v", value) 6883 } 6884 6885 var sv *types.BadRequestException 6886 if *v == nil { 6887 sv = &types.BadRequestException{} 6888 } else { 6889 sv = *v 6890 } 6891 6892 for key, value := range shape { 6893 switch key { 6894 case "message": 6895 if value != nil { 6896 jtv, ok := value.(string) 6897 if !ok { 6898 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6899 } 6900 sv.Message = ptr.String(jtv) 6901 } 6902 6903 default: 6904 _, _ = key, value 6905 6906 } 6907 } 6908 *v = sv 6909 return nil 6910} 6911 6912func awsRestjson1_deserializeDocumentCertificateAuthorityArns(v *[]string, value interface{}) error { 6913 if v == nil { 6914 return fmt.Errorf("unexpected nil of type %T", v) 6915 } 6916 if value == nil { 6917 return nil 6918 } 6919 6920 shape, ok := value.([]interface{}) 6921 if !ok { 6922 return fmt.Errorf("unexpected JSON type %v", value) 6923 } 6924 6925 var cv []string 6926 if *v == nil { 6927 cv = []string{} 6928 } else { 6929 cv = *v 6930 } 6931 6932 for _, value := range shape { 6933 var col string 6934 if value != nil { 6935 jtv, ok := value.(string) 6936 if !ok { 6937 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6938 } 6939 col = jtv 6940 } 6941 cv = append(cv, col) 6942 6943 } 6944 *v = cv 6945 return nil 6946} 6947 6948func awsRestjson1_deserializeDocumentClientPolicy(v **types.ClientPolicy, value interface{}) error { 6949 if v == nil { 6950 return fmt.Errorf("unexpected nil of type %T", v) 6951 } 6952 if value == nil { 6953 return nil 6954 } 6955 6956 shape, ok := value.(map[string]interface{}) 6957 if !ok { 6958 return fmt.Errorf("unexpected JSON type %v", value) 6959 } 6960 6961 var sv *types.ClientPolicy 6962 if *v == nil { 6963 sv = &types.ClientPolicy{} 6964 } else { 6965 sv = *v 6966 } 6967 6968 for key, value := range shape { 6969 switch key { 6970 case "tls": 6971 if err := awsRestjson1_deserializeDocumentClientPolicyTls(&sv.Tls, value); err != nil { 6972 return err 6973 } 6974 6975 default: 6976 _, _ = key, value 6977 6978 } 6979 } 6980 *v = sv 6981 return nil 6982} 6983 6984func awsRestjson1_deserializeDocumentClientPolicyTls(v **types.ClientPolicyTls, value interface{}) error { 6985 if v == nil { 6986 return fmt.Errorf("unexpected nil of type %T", v) 6987 } 6988 if value == nil { 6989 return nil 6990 } 6991 6992 shape, ok := value.(map[string]interface{}) 6993 if !ok { 6994 return fmt.Errorf("unexpected JSON type %v", value) 6995 } 6996 6997 var sv *types.ClientPolicyTls 6998 if *v == nil { 6999 sv = &types.ClientPolicyTls{} 7000 } else { 7001 sv = *v 7002 } 7003 7004 for key, value := range shape { 7005 switch key { 7006 case "certificate": 7007 if err := awsRestjson1_deserializeDocumentClientTlsCertificate(&sv.Certificate, value); err != nil { 7008 return err 7009 } 7010 7011 case "enforce": 7012 if value != nil { 7013 jtv, ok := value.(bool) 7014 if !ok { 7015 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7016 } 7017 sv.Enforce = ptr.Bool(jtv) 7018 } 7019 7020 case "ports": 7021 if err := awsRestjson1_deserializeDocumentPortSet(&sv.Ports, value); err != nil { 7022 return err 7023 } 7024 7025 case "validation": 7026 if err := awsRestjson1_deserializeDocumentTlsValidationContext(&sv.Validation, value); err != nil { 7027 return err 7028 } 7029 7030 default: 7031 _, _ = key, value 7032 7033 } 7034 } 7035 *v = sv 7036 return nil 7037} 7038 7039func awsRestjson1_deserializeDocumentClientTlsCertificate(v *types.ClientTlsCertificate, value interface{}) error { 7040 if v == nil { 7041 return fmt.Errorf("unexpected nil of type %T", v) 7042 } 7043 if value == nil { 7044 return nil 7045 } 7046 7047 shape, ok := value.(map[string]interface{}) 7048 if !ok { 7049 return fmt.Errorf("unexpected JSON type %v", value) 7050 } 7051 7052 var uv types.ClientTlsCertificate 7053loop: 7054 for key, value := range shape { 7055 if value == nil { 7056 continue 7057 } 7058 switch key { 7059 case "file": 7060 var mv types.ListenerTlsFileCertificate 7061 destAddr := &mv 7062 if err := awsRestjson1_deserializeDocumentListenerTlsFileCertificate(&destAddr, value); err != nil { 7063 return err 7064 } 7065 mv = *destAddr 7066 uv = &types.ClientTlsCertificateMemberFile{Value: mv} 7067 break loop 7068 7069 case "sds": 7070 var mv types.ListenerTlsSdsCertificate 7071 destAddr := &mv 7072 if err := awsRestjson1_deserializeDocumentListenerTlsSdsCertificate(&destAddr, value); err != nil { 7073 return err 7074 } 7075 mv = *destAddr 7076 uv = &types.ClientTlsCertificateMemberSds{Value: mv} 7077 break loop 7078 7079 default: 7080 uv = &types.UnknownUnionMember{Tag: key} 7081 break loop 7082 7083 } 7084 } 7085 *v = uv 7086 return nil 7087} 7088 7089func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 7090 if v == nil { 7091 return fmt.Errorf("unexpected nil of type %T", v) 7092 } 7093 if value == nil { 7094 return nil 7095 } 7096 7097 shape, ok := value.(map[string]interface{}) 7098 if !ok { 7099 return fmt.Errorf("unexpected JSON type %v", value) 7100 } 7101 7102 var sv *types.ConflictException 7103 if *v == nil { 7104 sv = &types.ConflictException{} 7105 } else { 7106 sv = *v 7107 } 7108 7109 for key, value := range shape { 7110 switch key { 7111 case "message": 7112 if value != nil { 7113 jtv, ok := value.(string) 7114 if !ok { 7115 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7116 } 7117 sv.Message = ptr.String(jtv) 7118 } 7119 7120 default: 7121 _, _ = key, value 7122 7123 } 7124 } 7125 *v = sv 7126 return nil 7127} 7128 7129func awsRestjson1_deserializeDocumentDnsServiceDiscovery(v **types.DnsServiceDiscovery, value interface{}) error { 7130 if v == nil { 7131 return fmt.Errorf("unexpected nil of type %T", v) 7132 } 7133 if value == nil { 7134 return nil 7135 } 7136 7137 shape, ok := value.(map[string]interface{}) 7138 if !ok { 7139 return fmt.Errorf("unexpected JSON type %v", value) 7140 } 7141 7142 var sv *types.DnsServiceDiscovery 7143 if *v == nil { 7144 sv = &types.DnsServiceDiscovery{} 7145 } else { 7146 sv = *v 7147 } 7148 7149 for key, value := range shape { 7150 switch key { 7151 case "hostname": 7152 if value != nil { 7153 jtv, ok := value.(string) 7154 if !ok { 7155 return fmt.Errorf("expected Hostname to be of type string, got %T instead", value) 7156 } 7157 sv.Hostname = ptr.String(jtv) 7158 } 7159 7160 default: 7161 _, _ = key, value 7162 7163 } 7164 } 7165 *v = sv 7166 return nil 7167} 7168 7169func awsRestjson1_deserializeDocumentDuration(v **types.Duration, value interface{}) error { 7170 if v == nil { 7171 return fmt.Errorf("unexpected nil of type %T", v) 7172 } 7173 if value == nil { 7174 return nil 7175 } 7176 7177 shape, ok := value.(map[string]interface{}) 7178 if !ok { 7179 return fmt.Errorf("unexpected JSON type %v", value) 7180 } 7181 7182 var sv *types.Duration 7183 if *v == nil { 7184 sv = &types.Duration{} 7185 } else { 7186 sv = *v 7187 } 7188 7189 for key, value := range shape { 7190 switch key { 7191 case "unit": 7192 if value != nil { 7193 jtv, ok := value.(string) 7194 if !ok { 7195 return fmt.Errorf("expected DurationUnit to be of type string, got %T instead", value) 7196 } 7197 sv.Unit = types.DurationUnit(jtv) 7198 } 7199 7200 case "value": 7201 if value != nil { 7202 jtv, ok := value.(json.Number) 7203 if !ok { 7204 return fmt.Errorf("expected DurationValue to be json.Number, got %T instead", value) 7205 } 7206 i64, err := jtv.Int64() 7207 if err != nil { 7208 return err 7209 } 7210 sv.Value = ptr.Int64(i64) 7211 } 7212 7213 default: 7214 _, _ = key, value 7215 7216 } 7217 } 7218 *v = sv 7219 return nil 7220} 7221 7222func awsRestjson1_deserializeDocumentEgressFilter(v **types.EgressFilter, value interface{}) error { 7223 if v == nil { 7224 return fmt.Errorf("unexpected nil of type %T", v) 7225 } 7226 if value == nil { 7227 return nil 7228 } 7229 7230 shape, ok := value.(map[string]interface{}) 7231 if !ok { 7232 return fmt.Errorf("unexpected JSON type %v", value) 7233 } 7234 7235 var sv *types.EgressFilter 7236 if *v == nil { 7237 sv = &types.EgressFilter{} 7238 } else { 7239 sv = *v 7240 } 7241 7242 for key, value := range shape { 7243 switch key { 7244 case "type": 7245 if value != nil { 7246 jtv, ok := value.(string) 7247 if !ok { 7248 return fmt.Errorf("expected EgressFilterType to be of type string, got %T instead", value) 7249 } 7250 sv.Type = types.EgressFilterType(jtv) 7251 } 7252 7253 default: 7254 _, _ = key, value 7255 7256 } 7257 } 7258 *v = sv 7259 return nil 7260} 7261 7262func awsRestjson1_deserializeDocumentFileAccessLog(v **types.FileAccessLog, value interface{}) error { 7263 if v == nil { 7264 return fmt.Errorf("unexpected nil of type %T", v) 7265 } 7266 if value == nil { 7267 return nil 7268 } 7269 7270 shape, ok := value.(map[string]interface{}) 7271 if !ok { 7272 return fmt.Errorf("unexpected JSON type %v", value) 7273 } 7274 7275 var sv *types.FileAccessLog 7276 if *v == nil { 7277 sv = &types.FileAccessLog{} 7278 } else { 7279 sv = *v 7280 } 7281 7282 for key, value := range shape { 7283 switch key { 7284 case "path": 7285 if value != nil { 7286 jtv, ok := value.(string) 7287 if !ok { 7288 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 7289 } 7290 sv.Path = ptr.String(jtv) 7291 } 7292 7293 default: 7294 _, _ = key, value 7295 7296 } 7297 } 7298 *v = sv 7299 return nil 7300} 7301 7302func awsRestjson1_deserializeDocumentForbiddenException(v **types.ForbiddenException, value interface{}) error { 7303 if v == nil { 7304 return fmt.Errorf("unexpected nil of type %T", v) 7305 } 7306 if value == nil { 7307 return nil 7308 } 7309 7310 shape, ok := value.(map[string]interface{}) 7311 if !ok { 7312 return fmt.Errorf("unexpected JSON type %v", value) 7313 } 7314 7315 var sv *types.ForbiddenException 7316 if *v == nil { 7317 sv = &types.ForbiddenException{} 7318 } else { 7319 sv = *v 7320 } 7321 7322 for key, value := range shape { 7323 switch key { 7324 case "message": 7325 if value != nil { 7326 jtv, ok := value.(string) 7327 if !ok { 7328 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7329 } 7330 sv.Message = ptr.String(jtv) 7331 } 7332 7333 default: 7334 _, _ = key, value 7335 7336 } 7337 } 7338 *v = sv 7339 return nil 7340} 7341 7342func awsRestjson1_deserializeDocumentGatewayRouteData(v **types.GatewayRouteData, value interface{}) error { 7343 if v == nil { 7344 return fmt.Errorf("unexpected nil of type %T", v) 7345 } 7346 if value == nil { 7347 return nil 7348 } 7349 7350 shape, ok := value.(map[string]interface{}) 7351 if !ok { 7352 return fmt.Errorf("unexpected JSON type %v", value) 7353 } 7354 7355 var sv *types.GatewayRouteData 7356 if *v == nil { 7357 sv = &types.GatewayRouteData{} 7358 } else { 7359 sv = *v 7360 } 7361 7362 for key, value := range shape { 7363 switch key { 7364 case "gatewayRouteName": 7365 if value != nil { 7366 jtv, ok := value.(string) 7367 if !ok { 7368 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7369 } 7370 sv.GatewayRouteName = ptr.String(jtv) 7371 } 7372 7373 case "meshName": 7374 if value != nil { 7375 jtv, ok := value.(string) 7376 if !ok { 7377 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7378 } 7379 sv.MeshName = ptr.String(jtv) 7380 } 7381 7382 case "metadata": 7383 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 7384 return err 7385 } 7386 7387 case "spec": 7388 if err := awsRestjson1_deserializeDocumentGatewayRouteSpec(&sv.Spec, value); err != nil { 7389 return err 7390 } 7391 7392 case "status": 7393 if err := awsRestjson1_deserializeDocumentGatewayRouteStatus(&sv.Status, value); err != nil { 7394 return err 7395 } 7396 7397 case "virtualGatewayName": 7398 if value != nil { 7399 jtv, ok := value.(string) 7400 if !ok { 7401 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7402 } 7403 sv.VirtualGatewayName = ptr.String(jtv) 7404 } 7405 7406 default: 7407 _, _ = key, value 7408 7409 } 7410 } 7411 *v = sv 7412 return nil 7413} 7414 7415func awsRestjson1_deserializeDocumentGatewayRouteList(v *[]types.GatewayRouteRef, value interface{}) error { 7416 if v == nil { 7417 return fmt.Errorf("unexpected nil of type %T", v) 7418 } 7419 if value == nil { 7420 return nil 7421 } 7422 7423 shape, ok := value.([]interface{}) 7424 if !ok { 7425 return fmt.Errorf("unexpected JSON type %v", value) 7426 } 7427 7428 var cv []types.GatewayRouteRef 7429 if *v == nil { 7430 cv = []types.GatewayRouteRef{} 7431 } else { 7432 cv = *v 7433 } 7434 7435 for _, value := range shape { 7436 var col types.GatewayRouteRef 7437 destAddr := &col 7438 if err := awsRestjson1_deserializeDocumentGatewayRouteRef(&destAddr, value); err != nil { 7439 return err 7440 } 7441 col = *destAddr 7442 cv = append(cv, col) 7443 7444 } 7445 *v = cv 7446 return nil 7447} 7448 7449func awsRestjson1_deserializeDocumentGatewayRouteRef(v **types.GatewayRouteRef, value interface{}) error { 7450 if v == nil { 7451 return fmt.Errorf("unexpected nil of type %T", v) 7452 } 7453 if value == nil { 7454 return nil 7455 } 7456 7457 shape, ok := value.(map[string]interface{}) 7458 if !ok { 7459 return fmt.Errorf("unexpected JSON type %v", value) 7460 } 7461 7462 var sv *types.GatewayRouteRef 7463 if *v == nil { 7464 sv = &types.GatewayRouteRef{} 7465 } else { 7466 sv = *v 7467 } 7468 7469 for key, value := range shape { 7470 switch key { 7471 case "arn": 7472 if value != nil { 7473 jtv, ok := value.(string) 7474 if !ok { 7475 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7476 } 7477 sv.Arn = ptr.String(jtv) 7478 } 7479 7480 case "createdAt": 7481 if value != nil { 7482 jtv, ok := value.(json.Number) 7483 if !ok { 7484 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7485 } 7486 f64, err := jtv.Float64() 7487 if err != nil { 7488 return err 7489 } 7490 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7491 } 7492 7493 case "gatewayRouteName": 7494 if value != nil { 7495 jtv, ok := value.(string) 7496 if !ok { 7497 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7498 } 7499 sv.GatewayRouteName = ptr.String(jtv) 7500 } 7501 7502 case "lastUpdatedAt": 7503 if value != nil { 7504 jtv, ok := value.(json.Number) 7505 if !ok { 7506 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7507 } 7508 f64, err := jtv.Float64() 7509 if err != nil { 7510 return err 7511 } 7512 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7513 } 7514 7515 case "meshName": 7516 if value != nil { 7517 jtv, ok := value.(string) 7518 if !ok { 7519 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7520 } 7521 sv.MeshName = ptr.String(jtv) 7522 } 7523 7524 case "meshOwner": 7525 if value != nil { 7526 jtv, ok := value.(string) 7527 if !ok { 7528 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 7529 } 7530 sv.MeshOwner = ptr.String(jtv) 7531 } 7532 7533 case "resourceOwner": 7534 if value != nil { 7535 jtv, ok := value.(string) 7536 if !ok { 7537 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 7538 } 7539 sv.ResourceOwner = ptr.String(jtv) 7540 } 7541 7542 case "version": 7543 if value != nil { 7544 jtv, ok := value.(json.Number) 7545 if !ok { 7546 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 7547 } 7548 i64, err := jtv.Int64() 7549 if err != nil { 7550 return err 7551 } 7552 sv.Version = ptr.Int64(i64) 7553 } 7554 7555 case "virtualGatewayName": 7556 if value != nil { 7557 jtv, ok := value.(string) 7558 if !ok { 7559 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7560 } 7561 sv.VirtualGatewayName = ptr.String(jtv) 7562 } 7563 7564 default: 7565 _, _ = key, value 7566 7567 } 7568 } 7569 *v = sv 7570 return nil 7571} 7572 7573func awsRestjson1_deserializeDocumentGatewayRouteSpec(v **types.GatewayRouteSpec, value interface{}) error { 7574 if v == nil { 7575 return fmt.Errorf("unexpected nil of type %T", v) 7576 } 7577 if value == nil { 7578 return nil 7579 } 7580 7581 shape, ok := value.(map[string]interface{}) 7582 if !ok { 7583 return fmt.Errorf("unexpected JSON type %v", value) 7584 } 7585 7586 var sv *types.GatewayRouteSpec 7587 if *v == nil { 7588 sv = &types.GatewayRouteSpec{} 7589 } else { 7590 sv = *v 7591 } 7592 7593 for key, value := range shape { 7594 switch key { 7595 case "grpcRoute": 7596 if err := awsRestjson1_deserializeDocumentGrpcGatewayRoute(&sv.GrpcRoute, value); err != nil { 7597 return err 7598 } 7599 7600 case "http2Route": 7601 if err := awsRestjson1_deserializeDocumentHttpGatewayRoute(&sv.Http2Route, value); err != nil { 7602 return err 7603 } 7604 7605 case "httpRoute": 7606 if err := awsRestjson1_deserializeDocumentHttpGatewayRoute(&sv.HttpRoute, value); err != nil { 7607 return err 7608 } 7609 7610 default: 7611 _, _ = key, value 7612 7613 } 7614 } 7615 *v = sv 7616 return nil 7617} 7618 7619func awsRestjson1_deserializeDocumentGatewayRouteStatus(v **types.GatewayRouteStatus, value interface{}) error { 7620 if v == nil { 7621 return fmt.Errorf("unexpected nil of type %T", v) 7622 } 7623 if value == nil { 7624 return nil 7625 } 7626 7627 shape, ok := value.(map[string]interface{}) 7628 if !ok { 7629 return fmt.Errorf("unexpected JSON type %v", value) 7630 } 7631 7632 var sv *types.GatewayRouteStatus 7633 if *v == nil { 7634 sv = &types.GatewayRouteStatus{} 7635 } else { 7636 sv = *v 7637 } 7638 7639 for key, value := range shape { 7640 switch key { 7641 case "status": 7642 if value != nil { 7643 jtv, ok := value.(string) 7644 if !ok { 7645 return fmt.Errorf("expected GatewayRouteStatusCode to be of type string, got %T instead", value) 7646 } 7647 sv.Status = types.GatewayRouteStatusCode(jtv) 7648 } 7649 7650 default: 7651 _, _ = key, value 7652 7653 } 7654 } 7655 *v = sv 7656 return nil 7657} 7658 7659func awsRestjson1_deserializeDocumentGatewayRouteTarget(v **types.GatewayRouteTarget, value interface{}) error { 7660 if v == nil { 7661 return fmt.Errorf("unexpected nil of type %T", v) 7662 } 7663 if value == nil { 7664 return nil 7665 } 7666 7667 shape, ok := value.(map[string]interface{}) 7668 if !ok { 7669 return fmt.Errorf("unexpected JSON type %v", value) 7670 } 7671 7672 var sv *types.GatewayRouteTarget 7673 if *v == nil { 7674 sv = &types.GatewayRouteTarget{} 7675 } else { 7676 sv = *v 7677 } 7678 7679 for key, value := range shape { 7680 switch key { 7681 case "virtualService": 7682 if err := awsRestjson1_deserializeDocumentGatewayRouteVirtualService(&sv.VirtualService, value); err != nil { 7683 return err 7684 } 7685 7686 default: 7687 _, _ = key, value 7688 7689 } 7690 } 7691 *v = sv 7692 return nil 7693} 7694 7695func awsRestjson1_deserializeDocumentGatewayRouteVirtualService(v **types.GatewayRouteVirtualService, value interface{}) error { 7696 if v == nil { 7697 return fmt.Errorf("unexpected nil of type %T", v) 7698 } 7699 if value == nil { 7700 return nil 7701 } 7702 7703 shape, ok := value.(map[string]interface{}) 7704 if !ok { 7705 return fmt.Errorf("unexpected JSON type %v", value) 7706 } 7707 7708 var sv *types.GatewayRouteVirtualService 7709 if *v == nil { 7710 sv = &types.GatewayRouteVirtualService{} 7711 } else { 7712 sv = *v 7713 } 7714 7715 for key, value := range shape { 7716 switch key { 7717 case "virtualServiceName": 7718 if value != nil { 7719 jtv, ok := value.(string) 7720 if !ok { 7721 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7722 } 7723 sv.VirtualServiceName = ptr.String(jtv) 7724 } 7725 7726 default: 7727 _, _ = key, value 7728 7729 } 7730 } 7731 *v = sv 7732 return nil 7733} 7734 7735func awsRestjson1_deserializeDocumentGrpcGatewayRoute(v **types.GrpcGatewayRoute, value interface{}) error { 7736 if v == nil { 7737 return fmt.Errorf("unexpected nil of type %T", v) 7738 } 7739 if value == nil { 7740 return nil 7741 } 7742 7743 shape, ok := value.(map[string]interface{}) 7744 if !ok { 7745 return fmt.Errorf("unexpected JSON type %v", value) 7746 } 7747 7748 var sv *types.GrpcGatewayRoute 7749 if *v == nil { 7750 sv = &types.GrpcGatewayRoute{} 7751 } else { 7752 sv = *v 7753 } 7754 7755 for key, value := range shape { 7756 switch key { 7757 case "action": 7758 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteAction(&sv.Action, value); err != nil { 7759 return err 7760 } 7761 7762 case "match": 7763 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteMatch(&sv.Match, value); err != nil { 7764 return err 7765 } 7766 7767 default: 7768 _, _ = key, value 7769 7770 } 7771 } 7772 *v = sv 7773 return nil 7774} 7775 7776func awsRestjson1_deserializeDocumentGrpcGatewayRouteAction(v **types.GrpcGatewayRouteAction, value interface{}) error { 7777 if v == nil { 7778 return fmt.Errorf("unexpected nil of type %T", v) 7779 } 7780 if value == nil { 7781 return nil 7782 } 7783 7784 shape, ok := value.(map[string]interface{}) 7785 if !ok { 7786 return fmt.Errorf("unexpected JSON type %v", value) 7787 } 7788 7789 var sv *types.GrpcGatewayRouteAction 7790 if *v == nil { 7791 sv = &types.GrpcGatewayRouteAction{} 7792 } else { 7793 sv = *v 7794 } 7795 7796 for key, value := range shape { 7797 switch key { 7798 case "target": 7799 if err := awsRestjson1_deserializeDocumentGatewayRouteTarget(&sv.Target, value); err != nil { 7800 return err 7801 } 7802 7803 default: 7804 _, _ = key, value 7805 7806 } 7807 } 7808 *v = sv 7809 return nil 7810} 7811 7812func awsRestjson1_deserializeDocumentGrpcGatewayRouteMatch(v **types.GrpcGatewayRouteMatch, value interface{}) error { 7813 if v == nil { 7814 return fmt.Errorf("unexpected nil of type %T", v) 7815 } 7816 if value == nil { 7817 return nil 7818 } 7819 7820 shape, ok := value.(map[string]interface{}) 7821 if !ok { 7822 return fmt.Errorf("unexpected JSON type %v", value) 7823 } 7824 7825 var sv *types.GrpcGatewayRouteMatch 7826 if *v == nil { 7827 sv = &types.GrpcGatewayRouteMatch{} 7828 } else { 7829 sv = *v 7830 } 7831 7832 for key, value := range shape { 7833 switch key { 7834 case "serviceName": 7835 if value != nil { 7836 jtv, ok := value.(string) 7837 if !ok { 7838 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 7839 } 7840 sv.ServiceName = ptr.String(jtv) 7841 } 7842 7843 default: 7844 _, _ = key, value 7845 7846 } 7847 } 7848 *v = sv 7849 return nil 7850} 7851 7852func awsRestjson1_deserializeDocumentGrpcRetryPolicy(v **types.GrpcRetryPolicy, value interface{}) error { 7853 if v == nil { 7854 return fmt.Errorf("unexpected nil of type %T", v) 7855 } 7856 if value == nil { 7857 return nil 7858 } 7859 7860 shape, ok := value.(map[string]interface{}) 7861 if !ok { 7862 return fmt.Errorf("unexpected JSON type %v", value) 7863 } 7864 7865 var sv *types.GrpcRetryPolicy 7866 if *v == nil { 7867 sv = &types.GrpcRetryPolicy{} 7868 } else { 7869 sv = *v 7870 } 7871 7872 for key, value := range shape { 7873 switch key { 7874 case "grpcRetryEvents": 7875 if err := awsRestjson1_deserializeDocumentGrpcRetryPolicyEvents(&sv.GrpcRetryEvents, value); err != nil { 7876 return err 7877 } 7878 7879 case "httpRetryEvents": 7880 if err := awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(&sv.HttpRetryEvents, value); err != nil { 7881 return err 7882 } 7883 7884 case "maxRetries": 7885 if value != nil { 7886 jtv, ok := value.(json.Number) 7887 if !ok { 7888 return fmt.Errorf("expected MaxRetries to be json.Number, got %T instead", value) 7889 } 7890 i64, err := jtv.Int64() 7891 if err != nil { 7892 return err 7893 } 7894 sv.MaxRetries = ptr.Int64(i64) 7895 } 7896 7897 case "perRetryTimeout": 7898 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRetryTimeout, value); err != nil { 7899 return err 7900 } 7901 7902 case "tcpRetryEvents": 7903 if err := awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(&sv.TcpRetryEvents, value); err != nil { 7904 return err 7905 } 7906 7907 default: 7908 _, _ = key, value 7909 7910 } 7911 } 7912 *v = sv 7913 return nil 7914} 7915 7916func awsRestjson1_deserializeDocumentGrpcRetryPolicyEvents(v *[]types.GrpcRetryPolicyEvent, value interface{}) error { 7917 if v == nil { 7918 return fmt.Errorf("unexpected nil of type %T", v) 7919 } 7920 if value == nil { 7921 return nil 7922 } 7923 7924 shape, ok := value.([]interface{}) 7925 if !ok { 7926 return fmt.Errorf("unexpected JSON type %v", value) 7927 } 7928 7929 var cv []types.GrpcRetryPolicyEvent 7930 if *v == nil { 7931 cv = []types.GrpcRetryPolicyEvent{} 7932 } else { 7933 cv = *v 7934 } 7935 7936 for _, value := range shape { 7937 var col types.GrpcRetryPolicyEvent 7938 if value != nil { 7939 jtv, ok := value.(string) 7940 if !ok { 7941 return fmt.Errorf("expected GrpcRetryPolicyEvent to be of type string, got %T instead", value) 7942 } 7943 col = types.GrpcRetryPolicyEvent(jtv) 7944 } 7945 cv = append(cv, col) 7946 7947 } 7948 *v = cv 7949 return nil 7950} 7951 7952func awsRestjson1_deserializeDocumentGrpcRoute(v **types.GrpcRoute, value interface{}) error { 7953 if v == nil { 7954 return fmt.Errorf("unexpected nil of type %T", v) 7955 } 7956 if value == nil { 7957 return nil 7958 } 7959 7960 shape, ok := value.(map[string]interface{}) 7961 if !ok { 7962 return fmt.Errorf("unexpected JSON type %v", value) 7963 } 7964 7965 var sv *types.GrpcRoute 7966 if *v == nil { 7967 sv = &types.GrpcRoute{} 7968 } else { 7969 sv = *v 7970 } 7971 7972 for key, value := range shape { 7973 switch key { 7974 case "action": 7975 if err := awsRestjson1_deserializeDocumentGrpcRouteAction(&sv.Action, value); err != nil { 7976 return err 7977 } 7978 7979 case "match": 7980 if err := awsRestjson1_deserializeDocumentGrpcRouteMatch(&sv.Match, value); err != nil { 7981 return err 7982 } 7983 7984 case "retryPolicy": 7985 if err := awsRestjson1_deserializeDocumentGrpcRetryPolicy(&sv.RetryPolicy, value); err != nil { 7986 return err 7987 } 7988 7989 case "timeout": 7990 if err := awsRestjson1_deserializeDocumentGrpcTimeout(&sv.Timeout, value); err != nil { 7991 return err 7992 } 7993 7994 default: 7995 _, _ = key, value 7996 7997 } 7998 } 7999 *v = sv 8000 return nil 8001} 8002 8003func awsRestjson1_deserializeDocumentGrpcRouteAction(v **types.GrpcRouteAction, value interface{}) error { 8004 if v == nil { 8005 return fmt.Errorf("unexpected nil of type %T", v) 8006 } 8007 if value == nil { 8008 return nil 8009 } 8010 8011 shape, ok := value.(map[string]interface{}) 8012 if !ok { 8013 return fmt.Errorf("unexpected JSON type %v", value) 8014 } 8015 8016 var sv *types.GrpcRouteAction 8017 if *v == nil { 8018 sv = &types.GrpcRouteAction{} 8019 } else { 8020 sv = *v 8021 } 8022 8023 for key, value := range shape { 8024 switch key { 8025 case "weightedTargets": 8026 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 8027 return err 8028 } 8029 8030 default: 8031 _, _ = key, value 8032 8033 } 8034 } 8035 *v = sv 8036 return nil 8037} 8038 8039func awsRestjson1_deserializeDocumentGrpcRouteMatch(v **types.GrpcRouteMatch, value interface{}) error { 8040 if v == nil { 8041 return fmt.Errorf("unexpected nil of type %T", v) 8042 } 8043 if value == nil { 8044 return nil 8045 } 8046 8047 shape, ok := value.(map[string]interface{}) 8048 if !ok { 8049 return fmt.Errorf("unexpected JSON type %v", value) 8050 } 8051 8052 var sv *types.GrpcRouteMatch 8053 if *v == nil { 8054 sv = &types.GrpcRouteMatch{} 8055 } else { 8056 sv = *v 8057 } 8058 8059 for key, value := range shape { 8060 switch key { 8061 case "metadata": 8062 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadataList(&sv.Metadata, value); err != nil { 8063 return err 8064 } 8065 8066 case "methodName": 8067 if value != nil { 8068 jtv, ok := value.(string) 8069 if !ok { 8070 return fmt.Errorf("expected MethodName to be of type string, got %T instead", value) 8071 } 8072 sv.MethodName = ptr.String(jtv) 8073 } 8074 8075 case "serviceName": 8076 if value != nil { 8077 jtv, ok := value.(string) 8078 if !ok { 8079 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 8080 } 8081 sv.ServiceName = ptr.String(jtv) 8082 } 8083 8084 default: 8085 _, _ = key, value 8086 8087 } 8088 } 8089 *v = sv 8090 return nil 8091} 8092 8093func awsRestjson1_deserializeDocumentGrpcRouteMetadata(v **types.GrpcRouteMetadata, value interface{}) error { 8094 if v == nil { 8095 return fmt.Errorf("unexpected nil of type %T", v) 8096 } 8097 if value == nil { 8098 return nil 8099 } 8100 8101 shape, ok := value.(map[string]interface{}) 8102 if !ok { 8103 return fmt.Errorf("unexpected JSON type %v", value) 8104 } 8105 8106 var sv *types.GrpcRouteMetadata 8107 if *v == nil { 8108 sv = &types.GrpcRouteMetadata{} 8109 } else { 8110 sv = *v 8111 } 8112 8113 for key, value := range shape { 8114 switch key { 8115 case "invert": 8116 if value != nil { 8117 jtv, ok := value.(bool) 8118 if !ok { 8119 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8120 } 8121 sv.Invert = ptr.Bool(jtv) 8122 } 8123 8124 case "match": 8125 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadataMatchMethod(&sv.Match, value); err != nil { 8126 return err 8127 } 8128 8129 case "name": 8130 if value != nil { 8131 jtv, ok := value.(string) 8132 if !ok { 8133 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 8134 } 8135 sv.Name = ptr.String(jtv) 8136 } 8137 8138 default: 8139 _, _ = key, value 8140 8141 } 8142 } 8143 *v = sv 8144 return nil 8145} 8146 8147func awsRestjson1_deserializeDocumentGrpcRouteMetadataList(v *[]types.GrpcRouteMetadata, value interface{}) error { 8148 if v == nil { 8149 return fmt.Errorf("unexpected nil of type %T", v) 8150 } 8151 if value == nil { 8152 return nil 8153 } 8154 8155 shape, ok := value.([]interface{}) 8156 if !ok { 8157 return fmt.Errorf("unexpected JSON type %v", value) 8158 } 8159 8160 var cv []types.GrpcRouteMetadata 8161 if *v == nil { 8162 cv = []types.GrpcRouteMetadata{} 8163 } else { 8164 cv = *v 8165 } 8166 8167 for _, value := range shape { 8168 var col types.GrpcRouteMetadata 8169 destAddr := &col 8170 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadata(&destAddr, value); err != nil { 8171 return err 8172 } 8173 col = *destAddr 8174 cv = append(cv, col) 8175 8176 } 8177 *v = cv 8178 return nil 8179} 8180 8181func awsRestjson1_deserializeDocumentGrpcRouteMetadataMatchMethod(v *types.GrpcRouteMetadataMatchMethod, value interface{}) error { 8182 if v == nil { 8183 return fmt.Errorf("unexpected nil of type %T", v) 8184 } 8185 if value == nil { 8186 return nil 8187 } 8188 8189 shape, ok := value.(map[string]interface{}) 8190 if !ok { 8191 return fmt.Errorf("unexpected JSON type %v", value) 8192 } 8193 8194 var uv types.GrpcRouteMetadataMatchMethod 8195loop: 8196 for key, value := range shape { 8197 if value == nil { 8198 continue 8199 } 8200 switch key { 8201 case "exact": 8202 var mv string 8203 if value != nil { 8204 jtv, ok := value.(string) 8205 if !ok { 8206 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8207 } 8208 mv = jtv 8209 } 8210 uv = &types.GrpcRouteMetadataMatchMethodMemberExact{Value: mv} 8211 break loop 8212 8213 case "prefix": 8214 var mv string 8215 if value != nil { 8216 jtv, ok := value.(string) 8217 if !ok { 8218 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8219 } 8220 mv = jtv 8221 } 8222 uv = &types.GrpcRouteMetadataMatchMethodMemberPrefix{Value: mv} 8223 break loop 8224 8225 case "range": 8226 var mv types.MatchRange 8227 destAddr := &mv 8228 if err := awsRestjson1_deserializeDocumentMatchRange(&destAddr, value); err != nil { 8229 return err 8230 } 8231 mv = *destAddr 8232 uv = &types.GrpcRouteMetadataMatchMethodMemberRange{Value: mv} 8233 break loop 8234 8235 case "regex": 8236 var mv string 8237 if value != nil { 8238 jtv, ok := value.(string) 8239 if !ok { 8240 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8241 } 8242 mv = jtv 8243 } 8244 uv = &types.GrpcRouteMetadataMatchMethodMemberRegex{Value: mv} 8245 break loop 8246 8247 case "suffix": 8248 var mv string 8249 if value != nil { 8250 jtv, ok := value.(string) 8251 if !ok { 8252 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8253 } 8254 mv = jtv 8255 } 8256 uv = &types.GrpcRouteMetadataMatchMethodMemberSuffix{Value: mv} 8257 break loop 8258 8259 default: 8260 uv = &types.UnknownUnionMember{Tag: key} 8261 break loop 8262 8263 } 8264 } 8265 *v = uv 8266 return nil 8267} 8268 8269func awsRestjson1_deserializeDocumentGrpcTimeout(v **types.GrpcTimeout, value interface{}) error { 8270 if v == nil { 8271 return fmt.Errorf("unexpected nil of type %T", v) 8272 } 8273 if value == nil { 8274 return nil 8275 } 8276 8277 shape, ok := value.(map[string]interface{}) 8278 if !ok { 8279 return fmt.Errorf("unexpected JSON type %v", value) 8280 } 8281 8282 var sv *types.GrpcTimeout 8283 if *v == nil { 8284 sv = &types.GrpcTimeout{} 8285 } else { 8286 sv = *v 8287 } 8288 8289 for key, value := range shape { 8290 switch key { 8291 case "idle": 8292 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 8293 return err 8294 } 8295 8296 case "perRequest": 8297 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRequest, value); err != nil { 8298 return err 8299 } 8300 8301 default: 8302 _, _ = key, value 8303 8304 } 8305 } 8306 *v = sv 8307 return nil 8308} 8309 8310func awsRestjson1_deserializeDocumentHeaderMatchMethod(v *types.HeaderMatchMethod, value interface{}) error { 8311 if v == nil { 8312 return fmt.Errorf("unexpected nil of type %T", v) 8313 } 8314 if value == nil { 8315 return nil 8316 } 8317 8318 shape, ok := value.(map[string]interface{}) 8319 if !ok { 8320 return fmt.Errorf("unexpected JSON type %v", value) 8321 } 8322 8323 var uv types.HeaderMatchMethod 8324loop: 8325 for key, value := range shape { 8326 if value == nil { 8327 continue 8328 } 8329 switch key { 8330 case "exact": 8331 var mv string 8332 if value != nil { 8333 jtv, ok := value.(string) 8334 if !ok { 8335 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8336 } 8337 mv = jtv 8338 } 8339 uv = &types.HeaderMatchMethodMemberExact{Value: mv} 8340 break loop 8341 8342 case "prefix": 8343 var mv string 8344 if value != nil { 8345 jtv, ok := value.(string) 8346 if !ok { 8347 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8348 } 8349 mv = jtv 8350 } 8351 uv = &types.HeaderMatchMethodMemberPrefix{Value: mv} 8352 break loop 8353 8354 case "range": 8355 var mv types.MatchRange 8356 destAddr := &mv 8357 if err := awsRestjson1_deserializeDocumentMatchRange(&destAddr, value); err != nil { 8358 return err 8359 } 8360 mv = *destAddr 8361 uv = &types.HeaderMatchMethodMemberRange{Value: mv} 8362 break loop 8363 8364 case "regex": 8365 var mv string 8366 if value != nil { 8367 jtv, ok := value.(string) 8368 if !ok { 8369 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8370 } 8371 mv = jtv 8372 } 8373 uv = &types.HeaderMatchMethodMemberRegex{Value: mv} 8374 break loop 8375 8376 case "suffix": 8377 var mv string 8378 if value != nil { 8379 jtv, ok := value.(string) 8380 if !ok { 8381 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8382 } 8383 mv = jtv 8384 } 8385 uv = &types.HeaderMatchMethodMemberSuffix{Value: mv} 8386 break loop 8387 8388 default: 8389 uv = &types.UnknownUnionMember{Tag: key} 8390 break loop 8391 8392 } 8393 } 8394 *v = uv 8395 return nil 8396} 8397 8398func awsRestjson1_deserializeDocumentHealthCheckPolicy(v **types.HealthCheckPolicy, value interface{}) error { 8399 if v == nil { 8400 return fmt.Errorf("unexpected nil of type %T", v) 8401 } 8402 if value == nil { 8403 return nil 8404 } 8405 8406 shape, ok := value.(map[string]interface{}) 8407 if !ok { 8408 return fmt.Errorf("unexpected JSON type %v", value) 8409 } 8410 8411 var sv *types.HealthCheckPolicy 8412 if *v == nil { 8413 sv = &types.HealthCheckPolicy{} 8414 } else { 8415 sv = *v 8416 } 8417 8418 for key, value := range shape { 8419 switch key { 8420 case "healthyThreshold": 8421 if value != nil { 8422 jtv, ok := value.(json.Number) 8423 if !ok { 8424 return fmt.Errorf("expected HealthCheckThreshold to be json.Number, got %T instead", value) 8425 } 8426 i64, err := jtv.Int64() 8427 if err != nil { 8428 return err 8429 } 8430 sv.HealthyThreshold = int32(i64) 8431 } 8432 8433 case "intervalMillis": 8434 if value != nil { 8435 jtv, ok := value.(json.Number) 8436 if !ok { 8437 return fmt.Errorf("expected HealthCheckIntervalMillis to be json.Number, got %T instead", value) 8438 } 8439 i64, err := jtv.Int64() 8440 if err != nil { 8441 return err 8442 } 8443 sv.IntervalMillis = ptr.Int64(i64) 8444 } 8445 8446 case "path": 8447 if value != nil { 8448 jtv, ok := value.(string) 8449 if !ok { 8450 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8451 } 8452 sv.Path = ptr.String(jtv) 8453 } 8454 8455 case "port": 8456 if value != nil { 8457 jtv, ok := value.(json.Number) 8458 if !ok { 8459 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8460 } 8461 i64, err := jtv.Int64() 8462 if err != nil { 8463 return err 8464 } 8465 sv.Port = int32(i64) 8466 } 8467 8468 case "protocol": 8469 if value != nil { 8470 jtv, ok := value.(string) 8471 if !ok { 8472 return fmt.Errorf("expected PortProtocol to be of type string, got %T instead", value) 8473 } 8474 sv.Protocol = types.PortProtocol(jtv) 8475 } 8476 8477 case "timeoutMillis": 8478 if value != nil { 8479 jtv, ok := value.(json.Number) 8480 if !ok { 8481 return fmt.Errorf("expected HealthCheckTimeoutMillis to be json.Number, got %T instead", value) 8482 } 8483 i64, err := jtv.Int64() 8484 if err != nil { 8485 return err 8486 } 8487 sv.TimeoutMillis = ptr.Int64(i64) 8488 } 8489 8490 case "unhealthyThreshold": 8491 if value != nil { 8492 jtv, ok := value.(json.Number) 8493 if !ok { 8494 return fmt.Errorf("expected HealthCheckThreshold to be json.Number, got %T instead", value) 8495 } 8496 i64, err := jtv.Int64() 8497 if err != nil { 8498 return err 8499 } 8500 sv.UnhealthyThreshold = int32(i64) 8501 } 8502 8503 default: 8504 _, _ = key, value 8505 8506 } 8507 } 8508 *v = sv 8509 return nil 8510} 8511 8512func awsRestjson1_deserializeDocumentHttpGatewayRoute(v **types.HttpGatewayRoute, value interface{}) error { 8513 if v == nil { 8514 return fmt.Errorf("unexpected nil of type %T", v) 8515 } 8516 if value == nil { 8517 return nil 8518 } 8519 8520 shape, ok := value.(map[string]interface{}) 8521 if !ok { 8522 return fmt.Errorf("unexpected JSON type %v", value) 8523 } 8524 8525 var sv *types.HttpGatewayRoute 8526 if *v == nil { 8527 sv = &types.HttpGatewayRoute{} 8528 } else { 8529 sv = *v 8530 } 8531 8532 for key, value := range shape { 8533 switch key { 8534 case "action": 8535 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteAction(&sv.Action, value); err != nil { 8536 return err 8537 } 8538 8539 case "match": 8540 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteMatch(&sv.Match, value); err != nil { 8541 return err 8542 } 8543 8544 default: 8545 _, _ = key, value 8546 8547 } 8548 } 8549 *v = sv 8550 return nil 8551} 8552 8553func awsRestjson1_deserializeDocumentHttpGatewayRouteAction(v **types.HttpGatewayRouteAction, value interface{}) error { 8554 if v == nil { 8555 return fmt.Errorf("unexpected nil of type %T", v) 8556 } 8557 if value == nil { 8558 return nil 8559 } 8560 8561 shape, ok := value.(map[string]interface{}) 8562 if !ok { 8563 return fmt.Errorf("unexpected JSON type %v", value) 8564 } 8565 8566 var sv *types.HttpGatewayRouteAction 8567 if *v == nil { 8568 sv = &types.HttpGatewayRouteAction{} 8569 } else { 8570 sv = *v 8571 } 8572 8573 for key, value := range shape { 8574 switch key { 8575 case "target": 8576 if err := awsRestjson1_deserializeDocumentGatewayRouteTarget(&sv.Target, value); err != nil { 8577 return err 8578 } 8579 8580 default: 8581 _, _ = key, value 8582 8583 } 8584 } 8585 *v = sv 8586 return nil 8587} 8588 8589func awsRestjson1_deserializeDocumentHttpGatewayRouteMatch(v **types.HttpGatewayRouteMatch, value interface{}) error { 8590 if v == nil { 8591 return fmt.Errorf("unexpected nil of type %T", v) 8592 } 8593 if value == nil { 8594 return nil 8595 } 8596 8597 shape, ok := value.(map[string]interface{}) 8598 if !ok { 8599 return fmt.Errorf("unexpected JSON type %v", value) 8600 } 8601 8602 var sv *types.HttpGatewayRouteMatch 8603 if *v == nil { 8604 sv = &types.HttpGatewayRouteMatch{} 8605 } else { 8606 sv = *v 8607 } 8608 8609 for key, value := range shape { 8610 switch key { 8611 case "prefix": 8612 if value != nil { 8613 jtv, ok := value.(string) 8614 if !ok { 8615 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8616 } 8617 sv.Prefix = ptr.String(jtv) 8618 } 8619 8620 default: 8621 _, _ = key, value 8622 8623 } 8624 } 8625 *v = sv 8626 return nil 8627} 8628 8629func awsRestjson1_deserializeDocumentHttpRetryPolicy(v **types.HttpRetryPolicy, value interface{}) error { 8630 if v == nil { 8631 return fmt.Errorf("unexpected nil of type %T", v) 8632 } 8633 if value == nil { 8634 return nil 8635 } 8636 8637 shape, ok := value.(map[string]interface{}) 8638 if !ok { 8639 return fmt.Errorf("unexpected JSON type %v", value) 8640 } 8641 8642 var sv *types.HttpRetryPolicy 8643 if *v == nil { 8644 sv = &types.HttpRetryPolicy{} 8645 } else { 8646 sv = *v 8647 } 8648 8649 for key, value := range shape { 8650 switch key { 8651 case "httpRetryEvents": 8652 if err := awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(&sv.HttpRetryEvents, value); err != nil { 8653 return err 8654 } 8655 8656 case "maxRetries": 8657 if value != nil { 8658 jtv, ok := value.(json.Number) 8659 if !ok { 8660 return fmt.Errorf("expected MaxRetries to be json.Number, got %T instead", value) 8661 } 8662 i64, err := jtv.Int64() 8663 if err != nil { 8664 return err 8665 } 8666 sv.MaxRetries = ptr.Int64(i64) 8667 } 8668 8669 case "perRetryTimeout": 8670 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRetryTimeout, value); err != nil { 8671 return err 8672 } 8673 8674 case "tcpRetryEvents": 8675 if err := awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(&sv.TcpRetryEvents, value); err != nil { 8676 return err 8677 } 8678 8679 default: 8680 _, _ = key, value 8681 8682 } 8683 } 8684 *v = sv 8685 return nil 8686} 8687 8688func awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(v *[]string, value interface{}) error { 8689 if v == nil { 8690 return fmt.Errorf("unexpected nil of type %T", v) 8691 } 8692 if value == nil { 8693 return nil 8694 } 8695 8696 shape, ok := value.([]interface{}) 8697 if !ok { 8698 return fmt.Errorf("unexpected JSON type %v", value) 8699 } 8700 8701 var cv []string 8702 if *v == nil { 8703 cv = []string{} 8704 } else { 8705 cv = *v 8706 } 8707 8708 for _, value := range shape { 8709 var col string 8710 if value != nil { 8711 jtv, ok := value.(string) 8712 if !ok { 8713 return fmt.Errorf("expected HttpRetryPolicyEvent to be of type string, got %T instead", value) 8714 } 8715 col = jtv 8716 } 8717 cv = append(cv, col) 8718 8719 } 8720 *v = cv 8721 return nil 8722} 8723 8724func awsRestjson1_deserializeDocumentHttpRoute(v **types.HttpRoute, value interface{}) error { 8725 if v == nil { 8726 return fmt.Errorf("unexpected nil of type %T", v) 8727 } 8728 if value == nil { 8729 return nil 8730 } 8731 8732 shape, ok := value.(map[string]interface{}) 8733 if !ok { 8734 return fmt.Errorf("unexpected JSON type %v", value) 8735 } 8736 8737 var sv *types.HttpRoute 8738 if *v == nil { 8739 sv = &types.HttpRoute{} 8740 } else { 8741 sv = *v 8742 } 8743 8744 for key, value := range shape { 8745 switch key { 8746 case "action": 8747 if err := awsRestjson1_deserializeDocumentHttpRouteAction(&sv.Action, value); err != nil { 8748 return err 8749 } 8750 8751 case "match": 8752 if err := awsRestjson1_deserializeDocumentHttpRouteMatch(&sv.Match, value); err != nil { 8753 return err 8754 } 8755 8756 case "retryPolicy": 8757 if err := awsRestjson1_deserializeDocumentHttpRetryPolicy(&sv.RetryPolicy, value); err != nil { 8758 return err 8759 } 8760 8761 case "timeout": 8762 if err := awsRestjson1_deserializeDocumentHttpTimeout(&sv.Timeout, value); err != nil { 8763 return err 8764 } 8765 8766 default: 8767 _, _ = key, value 8768 8769 } 8770 } 8771 *v = sv 8772 return nil 8773} 8774 8775func awsRestjson1_deserializeDocumentHttpRouteAction(v **types.HttpRouteAction, value interface{}) error { 8776 if v == nil { 8777 return fmt.Errorf("unexpected nil of type %T", v) 8778 } 8779 if value == nil { 8780 return nil 8781 } 8782 8783 shape, ok := value.(map[string]interface{}) 8784 if !ok { 8785 return fmt.Errorf("unexpected JSON type %v", value) 8786 } 8787 8788 var sv *types.HttpRouteAction 8789 if *v == nil { 8790 sv = &types.HttpRouteAction{} 8791 } else { 8792 sv = *v 8793 } 8794 8795 for key, value := range shape { 8796 switch key { 8797 case "weightedTargets": 8798 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 8799 return err 8800 } 8801 8802 default: 8803 _, _ = key, value 8804 8805 } 8806 } 8807 *v = sv 8808 return nil 8809} 8810 8811func awsRestjson1_deserializeDocumentHttpRouteHeader(v **types.HttpRouteHeader, value interface{}) error { 8812 if v == nil { 8813 return fmt.Errorf("unexpected nil of type %T", v) 8814 } 8815 if value == nil { 8816 return nil 8817 } 8818 8819 shape, ok := value.(map[string]interface{}) 8820 if !ok { 8821 return fmt.Errorf("unexpected JSON type %v", value) 8822 } 8823 8824 var sv *types.HttpRouteHeader 8825 if *v == nil { 8826 sv = &types.HttpRouteHeader{} 8827 } else { 8828 sv = *v 8829 } 8830 8831 for key, value := range shape { 8832 switch key { 8833 case "invert": 8834 if value != nil { 8835 jtv, ok := value.(bool) 8836 if !ok { 8837 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8838 } 8839 sv.Invert = ptr.Bool(jtv) 8840 } 8841 8842 case "match": 8843 if err := awsRestjson1_deserializeDocumentHeaderMatchMethod(&sv.Match, value); err != nil { 8844 return err 8845 } 8846 8847 case "name": 8848 if value != nil { 8849 jtv, ok := value.(string) 8850 if !ok { 8851 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 8852 } 8853 sv.Name = ptr.String(jtv) 8854 } 8855 8856 default: 8857 _, _ = key, value 8858 8859 } 8860 } 8861 *v = sv 8862 return nil 8863} 8864 8865func awsRestjson1_deserializeDocumentHttpRouteHeaders(v *[]types.HttpRouteHeader, value interface{}) error { 8866 if v == nil { 8867 return fmt.Errorf("unexpected nil of type %T", v) 8868 } 8869 if value == nil { 8870 return nil 8871 } 8872 8873 shape, ok := value.([]interface{}) 8874 if !ok { 8875 return fmt.Errorf("unexpected JSON type %v", value) 8876 } 8877 8878 var cv []types.HttpRouteHeader 8879 if *v == nil { 8880 cv = []types.HttpRouteHeader{} 8881 } else { 8882 cv = *v 8883 } 8884 8885 for _, value := range shape { 8886 var col types.HttpRouteHeader 8887 destAddr := &col 8888 if err := awsRestjson1_deserializeDocumentHttpRouteHeader(&destAddr, value); err != nil { 8889 return err 8890 } 8891 col = *destAddr 8892 cv = append(cv, col) 8893 8894 } 8895 *v = cv 8896 return nil 8897} 8898 8899func awsRestjson1_deserializeDocumentHttpRouteMatch(v **types.HttpRouteMatch, value interface{}) error { 8900 if v == nil { 8901 return fmt.Errorf("unexpected nil of type %T", v) 8902 } 8903 if value == nil { 8904 return nil 8905 } 8906 8907 shape, ok := value.(map[string]interface{}) 8908 if !ok { 8909 return fmt.Errorf("unexpected JSON type %v", value) 8910 } 8911 8912 var sv *types.HttpRouteMatch 8913 if *v == nil { 8914 sv = &types.HttpRouteMatch{} 8915 } else { 8916 sv = *v 8917 } 8918 8919 for key, value := range shape { 8920 switch key { 8921 case "headers": 8922 if err := awsRestjson1_deserializeDocumentHttpRouteHeaders(&sv.Headers, value); err != nil { 8923 return err 8924 } 8925 8926 case "method": 8927 if value != nil { 8928 jtv, ok := value.(string) 8929 if !ok { 8930 return fmt.Errorf("expected HttpMethod to be of type string, got %T instead", value) 8931 } 8932 sv.Method = types.HttpMethod(jtv) 8933 } 8934 8935 case "prefix": 8936 if value != nil { 8937 jtv, ok := value.(string) 8938 if !ok { 8939 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8940 } 8941 sv.Prefix = ptr.String(jtv) 8942 } 8943 8944 case "scheme": 8945 if value != nil { 8946 jtv, ok := value.(string) 8947 if !ok { 8948 return fmt.Errorf("expected HttpScheme to be of type string, got %T instead", value) 8949 } 8950 sv.Scheme = types.HttpScheme(jtv) 8951 } 8952 8953 default: 8954 _, _ = key, value 8955 8956 } 8957 } 8958 *v = sv 8959 return nil 8960} 8961 8962func awsRestjson1_deserializeDocumentHttpTimeout(v **types.HttpTimeout, value interface{}) error { 8963 if v == nil { 8964 return fmt.Errorf("unexpected nil of type %T", v) 8965 } 8966 if value == nil { 8967 return nil 8968 } 8969 8970 shape, ok := value.(map[string]interface{}) 8971 if !ok { 8972 return fmt.Errorf("unexpected JSON type %v", value) 8973 } 8974 8975 var sv *types.HttpTimeout 8976 if *v == nil { 8977 sv = &types.HttpTimeout{} 8978 } else { 8979 sv = *v 8980 } 8981 8982 for key, value := range shape { 8983 switch key { 8984 case "idle": 8985 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 8986 return err 8987 } 8988 8989 case "perRequest": 8990 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRequest, value); err != nil { 8991 return err 8992 } 8993 8994 default: 8995 _, _ = key, value 8996 8997 } 8998 } 8999 *v = sv 9000 return nil 9001} 9002 9003func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 9004 if v == nil { 9005 return fmt.Errorf("unexpected nil of type %T", v) 9006 } 9007 if value == nil { 9008 return nil 9009 } 9010 9011 shape, ok := value.(map[string]interface{}) 9012 if !ok { 9013 return fmt.Errorf("unexpected JSON type %v", value) 9014 } 9015 9016 var sv *types.InternalServerErrorException 9017 if *v == nil { 9018 sv = &types.InternalServerErrorException{} 9019 } else { 9020 sv = *v 9021 } 9022 9023 for key, value := range shape { 9024 switch key { 9025 case "message": 9026 if value != nil { 9027 jtv, ok := value.(string) 9028 if !ok { 9029 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9030 } 9031 sv.Message = ptr.String(jtv) 9032 } 9033 9034 default: 9035 _, _ = key, value 9036 9037 } 9038 } 9039 *v = sv 9040 return nil 9041} 9042 9043func awsRestjson1_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 9044 if v == nil { 9045 return fmt.Errorf("unexpected nil of type %T", v) 9046 } 9047 if value == nil { 9048 return nil 9049 } 9050 9051 shape, ok := value.(map[string]interface{}) 9052 if !ok { 9053 return fmt.Errorf("unexpected JSON type %v", value) 9054 } 9055 9056 var sv *types.LimitExceededException 9057 if *v == nil { 9058 sv = &types.LimitExceededException{} 9059 } else { 9060 sv = *v 9061 } 9062 9063 for key, value := range shape { 9064 switch key { 9065 case "message": 9066 if value != nil { 9067 jtv, ok := value.(string) 9068 if !ok { 9069 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9070 } 9071 sv.Message = ptr.String(jtv) 9072 } 9073 9074 default: 9075 _, _ = key, value 9076 9077 } 9078 } 9079 *v = sv 9080 return nil 9081} 9082 9083func awsRestjson1_deserializeDocumentListener(v **types.Listener, value interface{}) error { 9084 if v == nil { 9085 return fmt.Errorf("unexpected nil of type %T", v) 9086 } 9087 if value == nil { 9088 return nil 9089 } 9090 9091 shape, ok := value.(map[string]interface{}) 9092 if !ok { 9093 return fmt.Errorf("unexpected JSON type %v", value) 9094 } 9095 9096 var sv *types.Listener 9097 if *v == nil { 9098 sv = &types.Listener{} 9099 } else { 9100 sv = *v 9101 } 9102 9103 for key, value := range shape { 9104 switch key { 9105 case "connectionPool": 9106 if err := awsRestjson1_deserializeDocumentVirtualNodeConnectionPool(&sv.ConnectionPool, value); err != nil { 9107 return err 9108 } 9109 9110 case "healthCheck": 9111 if err := awsRestjson1_deserializeDocumentHealthCheckPolicy(&sv.HealthCheck, value); err != nil { 9112 return err 9113 } 9114 9115 case "outlierDetection": 9116 if err := awsRestjson1_deserializeDocumentOutlierDetection(&sv.OutlierDetection, value); err != nil { 9117 return err 9118 } 9119 9120 case "portMapping": 9121 if err := awsRestjson1_deserializeDocumentPortMapping(&sv.PortMapping, value); err != nil { 9122 return err 9123 } 9124 9125 case "timeout": 9126 if err := awsRestjson1_deserializeDocumentListenerTimeout(&sv.Timeout, value); err != nil { 9127 return err 9128 } 9129 9130 case "tls": 9131 if err := awsRestjson1_deserializeDocumentListenerTls(&sv.Tls, value); err != nil { 9132 return err 9133 } 9134 9135 default: 9136 _, _ = key, value 9137 9138 } 9139 } 9140 *v = sv 9141 return nil 9142} 9143 9144func awsRestjson1_deserializeDocumentListeners(v *[]types.Listener, value interface{}) error { 9145 if v == nil { 9146 return fmt.Errorf("unexpected nil of type %T", v) 9147 } 9148 if value == nil { 9149 return nil 9150 } 9151 9152 shape, ok := value.([]interface{}) 9153 if !ok { 9154 return fmt.Errorf("unexpected JSON type %v", value) 9155 } 9156 9157 var cv []types.Listener 9158 if *v == nil { 9159 cv = []types.Listener{} 9160 } else { 9161 cv = *v 9162 } 9163 9164 for _, value := range shape { 9165 var col types.Listener 9166 destAddr := &col 9167 if err := awsRestjson1_deserializeDocumentListener(&destAddr, value); err != nil { 9168 return err 9169 } 9170 col = *destAddr 9171 cv = append(cv, col) 9172 9173 } 9174 *v = cv 9175 return nil 9176} 9177 9178func awsRestjson1_deserializeDocumentListenerTimeout(v *types.ListenerTimeout, value interface{}) error { 9179 if v == nil { 9180 return fmt.Errorf("unexpected nil of type %T", v) 9181 } 9182 if value == nil { 9183 return nil 9184 } 9185 9186 shape, ok := value.(map[string]interface{}) 9187 if !ok { 9188 return fmt.Errorf("unexpected JSON type %v", value) 9189 } 9190 9191 var uv types.ListenerTimeout 9192loop: 9193 for key, value := range shape { 9194 if value == nil { 9195 continue 9196 } 9197 switch key { 9198 case "grpc": 9199 var mv types.GrpcTimeout 9200 destAddr := &mv 9201 if err := awsRestjson1_deserializeDocumentGrpcTimeout(&destAddr, value); err != nil { 9202 return err 9203 } 9204 mv = *destAddr 9205 uv = &types.ListenerTimeoutMemberGrpc{Value: mv} 9206 break loop 9207 9208 case "http": 9209 var mv types.HttpTimeout 9210 destAddr := &mv 9211 if err := awsRestjson1_deserializeDocumentHttpTimeout(&destAddr, value); err != nil { 9212 return err 9213 } 9214 mv = *destAddr 9215 uv = &types.ListenerTimeoutMemberHttp{Value: mv} 9216 break loop 9217 9218 case "http2": 9219 var mv types.HttpTimeout 9220 destAddr := &mv 9221 if err := awsRestjson1_deserializeDocumentHttpTimeout(&destAddr, value); err != nil { 9222 return err 9223 } 9224 mv = *destAddr 9225 uv = &types.ListenerTimeoutMemberHttp2{Value: mv} 9226 break loop 9227 9228 case "tcp": 9229 var mv types.TcpTimeout 9230 destAddr := &mv 9231 if err := awsRestjson1_deserializeDocumentTcpTimeout(&destAddr, value); err != nil { 9232 return err 9233 } 9234 mv = *destAddr 9235 uv = &types.ListenerTimeoutMemberTcp{Value: mv} 9236 break loop 9237 9238 default: 9239 uv = &types.UnknownUnionMember{Tag: key} 9240 break loop 9241 9242 } 9243 } 9244 *v = uv 9245 return nil 9246} 9247 9248func awsRestjson1_deserializeDocumentListenerTls(v **types.ListenerTls, value interface{}) error { 9249 if v == nil { 9250 return fmt.Errorf("unexpected nil of type %T", v) 9251 } 9252 if value == nil { 9253 return nil 9254 } 9255 9256 shape, ok := value.(map[string]interface{}) 9257 if !ok { 9258 return fmt.Errorf("unexpected JSON type %v", value) 9259 } 9260 9261 var sv *types.ListenerTls 9262 if *v == nil { 9263 sv = &types.ListenerTls{} 9264 } else { 9265 sv = *v 9266 } 9267 9268 for key, value := range shape { 9269 switch key { 9270 case "certificate": 9271 if err := awsRestjson1_deserializeDocumentListenerTlsCertificate(&sv.Certificate, value); err != nil { 9272 return err 9273 } 9274 9275 case "mode": 9276 if value != nil { 9277 jtv, ok := value.(string) 9278 if !ok { 9279 return fmt.Errorf("expected ListenerTlsMode to be of type string, got %T instead", value) 9280 } 9281 sv.Mode = types.ListenerTlsMode(jtv) 9282 } 9283 9284 case "validation": 9285 if err := awsRestjson1_deserializeDocumentListenerTlsValidationContext(&sv.Validation, value); err != nil { 9286 return err 9287 } 9288 9289 default: 9290 _, _ = key, value 9291 9292 } 9293 } 9294 *v = sv 9295 return nil 9296} 9297 9298func awsRestjson1_deserializeDocumentListenerTlsAcmCertificate(v **types.ListenerTlsAcmCertificate, value interface{}) error { 9299 if v == nil { 9300 return fmt.Errorf("unexpected nil of type %T", v) 9301 } 9302 if value == nil { 9303 return nil 9304 } 9305 9306 shape, ok := value.(map[string]interface{}) 9307 if !ok { 9308 return fmt.Errorf("unexpected JSON type %v", value) 9309 } 9310 9311 var sv *types.ListenerTlsAcmCertificate 9312 if *v == nil { 9313 sv = &types.ListenerTlsAcmCertificate{} 9314 } else { 9315 sv = *v 9316 } 9317 9318 for key, value := range shape { 9319 switch key { 9320 case "certificateArn": 9321 if value != nil { 9322 jtv, ok := value.(string) 9323 if !ok { 9324 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9325 } 9326 sv.CertificateArn = ptr.String(jtv) 9327 } 9328 9329 default: 9330 _, _ = key, value 9331 9332 } 9333 } 9334 *v = sv 9335 return nil 9336} 9337 9338func awsRestjson1_deserializeDocumentListenerTlsCertificate(v *types.ListenerTlsCertificate, value interface{}) error { 9339 if v == nil { 9340 return fmt.Errorf("unexpected nil of type %T", v) 9341 } 9342 if value == nil { 9343 return nil 9344 } 9345 9346 shape, ok := value.(map[string]interface{}) 9347 if !ok { 9348 return fmt.Errorf("unexpected JSON type %v", value) 9349 } 9350 9351 var uv types.ListenerTlsCertificate 9352loop: 9353 for key, value := range shape { 9354 if value == nil { 9355 continue 9356 } 9357 switch key { 9358 case "acm": 9359 var mv types.ListenerTlsAcmCertificate 9360 destAddr := &mv 9361 if err := awsRestjson1_deserializeDocumentListenerTlsAcmCertificate(&destAddr, value); err != nil { 9362 return err 9363 } 9364 mv = *destAddr 9365 uv = &types.ListenerTlsCertificateMemberAcm{Value: mv} 9366 break loop 9367 9368 case "file": 9369 var mv types.ListenerTlsFileCertificate 9370 destAddr := &mv 9371 if err := awsRestjson1_deserializeDocumentListenerTlsFileCertificate(&destAddr, value); err != nil { 9372 return err 9373 } 9374 mv = *destAddr 9375 uv = &types.ListenerTlsCertificateMemberFile{Value: mv} 9376 break loop 9377 9378 case "sds": 9379 var mv types.ListenerTlsSdsCertificate 9380 destAddr := &mv 9381 if err := awsRestjson1_deserializeDocumentListenerTlsSdsCertificate(&destAddr, value); err != nil { 9382 return err 9383 } 9384 mv = *destAddr 9385 uv = &types.ListenerTlsCertificateMemberSds{Value: mv} 9386 break loop 9387 9388 default: 9389 uv = &types.UnknownUnionMember{Tag: key} 9390 break loop 9391 9392 } 9393 } 9394 *v = uv 9395 return nil 9396} 9397 9398func awsRestjson1_deserializeDocumentListenerTlsFileCertificate(v **types.ListenerTlsFileCertificate, value interface{}) error { 9399 if v == nil { 9400 return fmt.Errorf("unexpected nil of type %T", v) 9401 } 9402 if value == nil { 9403 return nil 9404 } 9405 9406 shape, ok := value.(map[string]interface{}) 9407 if !ok { 9408 return fmt.Errorf("unexpected JSON type %v", value) 9409 } 9410 9411 var sv *types.ListenerTlsFileCertificate 9412 if *v == nil { 9413 sv = &types.ListenerTlsFileCertificate{} 9414 } else { 9415 sv = *v 9416 } 9417 9418 for key, value := range shape { 9419 switch key { 9420 case "certificateChain": 9421 if value != nil { 9422 jtv, ok := value.(string) 9423 if !ok { 9424 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 9425 } 9426 sv.CertificateChain = ptr.String(jtv) 9427 } 9428 9429 case "privateKey": 9430 if value != nil { 9431 jtv, ok := value.(string) 9432 if !ok { 9433 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 9434 } 9435 sv.PrivateKey = ptr.String(jtv) 9436 } 9437 9438 default: 9439 _, _ = key, value 9440 9441 } 9442 } 9443 *v = sv 9444 return nil 9445} 9446 9447func awsRestjson1_deserializeDocumentListenerTlsSdsCertificate(v **types.ListenerTlsSdsCertificate, value interface{}) error { 9448 if v == nil { 9449 return fmt.Errorf("unexpected nil of type %T", v) 9450 } 9451 if value == nil { 9452 return nil 9453 } 9454 9455 shape, ok := value.(map[string]interface{}) 9456 if !ok { 9457 return fmt.Errorf("unexpected JSON type %v", value) 9458 } 9459 9460 var sv *types.ListenerTlsSdsCertificate 9461 if *v == nil { 9462 sv = &types.ListenerTlsSdsCertificate{} 9463 } else { 9464 sv = *v 9465 } 9466 9467 for key, value := range shape { 9468 switch key { 9469 case "secretName": 9470 if value != nil { 9471 jtv, ok := value.(string) 9472 if !ok { 9473 return fmt.Errorf("expected SdsSecretName to be of type string, got %T instead", value) 9474 } 9475 sv.SecretName = ptr.String(jtv) 9476 } 9477 9478 default: 9479 _, _ = key, value 9480 9481 } 9482 } 9483 *v = sv 9484 return nil 9485} 9486 9487func awsRestjson1_deserializeDocumentListenerTlsValidationContext(v **types.ListenerTlsValidationContext, value interface{}) error { 9488 if v == nil { 9489 return fmt.Errorf("unexpected nil of type %T", v) 9490 } 9491 if value == nil { 9492 return nil 9493 } 9494 9495 shape, ok := value.(map[string]interface{}) 9496 if !ok { 9497 return fmt.Errorf("unexpected JSON type %v", value) 9498 } 9499 9500 var sv *types.ListenerTlsValidationContext 9501 if *v == nil { 9502 sv = &types.ListenerTlsValidationContext{} 9503 } else { 9504 sv = *v 9505 } 9506 9507 for key, value := range shape { 9508 switch key { 9509 case "subjectAlternativeNames": 9510 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 9511 return err 9512 } 9513 9514 case "trust": 9515 if err := awsRestjson1_deserializeDocumentListenerTlsValidationContextTrust(&sv.Trust, value); err != nil { 9516 return err 9517 } 9518 9519 default: 9520 _, _ = key, value 9521 9522 } 9523 } 9524 *v = sv 9525 return nil 9526} 9527 9528func awsRestjson1_deserializeDocumentListenerTlsValidationContextTrust(v *types.ListenerTlsValidationContextTrust, value interface{}) error { 9529 if v == nil { 9530 return fmt.Errorf("unexpected nil of type %T", v) 9531 } 9532 if value == nil { 9533 return nil 9534 } 9535 9536 shape, ok := value.(map[string]interface{}) 9537 if !ok { 9538 return fmt.Errorf("unexpected JSON type %v", value) 9539 } 9540 9541 var uv types.ListenerTlsValidationContextTrust 9542loop: 9543 for key, value := range shape { 9544 if value == nil { 9545 continue 9546 } 9547 switch key { 9548 case "file": 9549 var mv types.TlsValidationContextFileTrust 9550 destAddr := &mv 9551 if err := awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(&destAddr, value); err != nil { 9552 return err 9553 } 9554 mv = *destAddr 9555 uv = &types.ListenerTlsValidationContextTrustMemberFile{Value: mv} 9556 break loop 9557 9558 case "sds": 9559 var mv types.TlsValidationContextSdsTrust 9560 destAddr := &mv 9561 if err := awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(&destAddr, value); err != nil { 9562 return err 9563 } 9564 mv = *destAddr 9565 uv = &types.ListenerTlsValidationContextTrustMemberSds{Value: mv} 9566 break loop 9567 9568 default: 9569 uv = &types.UnknownUnionMember{Tag: key} 9570 break loop 9571 9572 } 9573 } 9574 *v = uv 9575 return nil 9576} 9577 9578func awsRestjson1_deserializeDocumentLogging(v **types.Logging, value interface{}) error { 9579 if v == nil { 9580 return fmt.Errorf("unexpected nil of type %T", v) 9581 } 9582 if value == nil { 9583 return nil 9584 } 9585 9586 shape, ok := value.(map[string]interface{}) 9587 if !ok { 9588 return fmt.Errorf("unexpected JSON type %v", value) 9589 } 9590 9591 var sv *types.Logging 9592 if *v == nil { 9593 sv = &types.Logging{} 9594 } else { 9595 sv = *v 9596 } 9597 9598 for key, value := range shape { 9599 switch key { 9600 case "accessLog": 9601 if err := awsRestjson1_deserializeDocumentAccessLog(&sv.AccessLog, value); err != nil { 9602 return err 9603 } 9604 9605 default: 9606 _, _ = key, value 9607 9608 } 9609 } 9610 *v = sv 9611 return nil 9612} 9613 9614func awsRestjson1_deserializeDocumentMatchRange(v **types.MatchRange, value interface{}) error { 9615 if v == nil { 9616 return fmt.Errorf("unexpected nil of type %T", v) 9617 } 9618 if value == nil { 9619 return nil 9620 } 9621 9622 shape, ok := value.(map[string]interface{}) 9623 if !ok { 9624 return fmt.Errorf("unexpected JSON type %v", value) 9625 } 9626 9627 var sv *types.MatchRange 9628 if *v == nil { 9629 sv = &types.MatchRange{} 9630 } else { 9631 sv = *v 9632 } 9633 9634 for key, value := range shape { 9635 switch key { 9636 case "end": 9637 if value != nil { 9638 jtv, ok := value.(json.Number) 9639 if !ok { 9640 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 9641 } 9642 i64, err := jtv.Int64() 9643 if err != nil { 9644 return err 9645 } 9646 sv.End = ptr.Int64(i64) 9647 } 9648 9649 case "start": 9650 if value != nil { 9651 jtv, ok := value.(json.Number) 9652 if !ok { 9653 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 9654 } 9655 i64, err := jtv.Int64() 9656 if err != nil { 9657 return err 9658 } 9659 sv.Start = ptr.Int64(i64) 9660 } 9661 9662 default: 9663 _, _ = key, value 9664 9665 } 9666 } 9667 *v = sv 9668 return nil 9669} 9670 9671func awsRestjson1_deserializeDocumentMeshData(v **types.MeshData, value interface{}) error { 9672 if v == nil { 9673 return fmt.Errorf("unexpected nil of type %T", v) 9674 } 9675 if value == nil { 9676 return nil 9677 } 9678 9679 shape, ok := value.(map[string]interface{}) 9680 if !ok { 9681 return fmt.Errorf("unexpected JSON type %v", value) 9682 } 9683 9684 var sv *types.MeshData 9685 if *v == nil { 9686 sv = &types.MeshData{} 9687 } else { 9688 sv = *v 9689 } 9690 9691 for key, value := range shape { 9692 switch key { 9693 case "meshName": 9694 if value != nil { 9695 jtv, ok := value.(string) 9696 if !ok { 9697 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 9698 } 9699 sv.MeshName = ptr.String(jtv) 9700 } 9701 9702 case "metadata": 9703 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 9704 return err 9705 } 9706 9707 case "spec": 9708 if err := awsRestjson1_deserializeDocumentMeshSpec(&sv.Spec, value); err != nil { 9709 return err 9710 } 9711 9712 case "status": 9713 if err := awsRestjson1_deserializeDocumentMeshStatus(&sv.Status, value); err != nil { 9714 return err 9715 } 9716 9717 default: 9718 _, _ = key, value 9719 9720 } 9721 } 9722 *v = sv 9723 return nil 9724} 9725 9726func awsRestjson1_deserializeDocumentMeshList(v *[]types.MeshRef, value interface{}) error { 9727 if v == nil { 9728 return fmt.Errorf("unexpected nil of type %T", v) 9729 } 9730 if value == nil { 9731 return nil 9732 } 9733 9734 shape, ok := value.([]interface{}) 9735 if !ok { 9736 return fmt.Errorf("unexpected JSON type %v", value) 9737 } 9738 9739 var cv []types.MeshRef 9740 if *v == nil { 9741 cv = []types.MeshRef{} 9742 } else { 9743 cv = *v 9744 } 9745 9746 for _, value := range shape { 9747 var col types.MeshRef 9748 destAddr := &col 9749 if err := awsRestjson1_deserializeDocumentMeshRef(&destAddr, value); err != nil { 9750 return err 9751 } 9752 col = *destAddr 9753 cv = append(cv, col) 9754 9755 } 9756 *v = cv 9757 return nil 9758} 9759 9760func awsRestjson1_deserializeDocumentMeshRef(v **types.MeshRef, value interface{}) error { 9761 if v == nil { 9762 return fmt.Errorf("unexpected nil of type %T", v) 9763 } 9764 if value == nil { 9765 return nil 9766 } 9767 9768 shape, ok := value.(map[string]interface{}) 9769 if !ok { 9770 return fmt.Errorf("unexpected JSON type %v", value) 9771 } 9772 9773 var sv *types.MeshRef 9774 if *v == nil { 9775 sv = &types.MeshRef{} 9776 } else { 9777 sv = *v 9778 } 9779 9780 for key, value := range shape { 9781 switch key { 9782 case "arn": 9783 if value != nil { 9784 jtv, ok := value.(string) 9785 if !ok { 9786 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9787 } 9788 sv.Arn = ptr.String(jtv) 9789 } 9790 9791 case "createdAt": 9792 if value != nil { 9793 jtv, ok := value.(json.Number) 9794 if !ok { 9795 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9796 } 9797 f64, err := jtv.Float64() 9798 if err != nil { 9799 return err 9800 } 9801 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9802 } 9803 9804 case "lastUpdatedAt": 9805 if value != nil { 9806 jtv, ok := value.(json.Number) 9807 if !ok { 9808 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9809 } 9810 f64, err := jtv.Float64() 9811 if err != nil { 9812 return err 9813 } 9814 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9815 } 9816 9817 case "meshName": 9818 if value != nil { 9819 jtv, ok := value.(string) 9820 if !ok { 9821 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 9822 } 9823 sv.MeshName = ptr.String(jtv) 9824 } 9825 9826 case "meshOwner": 9827 if value != nil { 9828 jtv, ok := value.(string) 9829 if !ok { 9830 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9831 } 9832 sv.MeshOwner = ptr.String(jtv) 9833 } 9834 9835 case "resourceOwner": 9836 if value != nil { 9837 jtv, ok := value.(string) 9838 if !ok { 9839 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 9840 } 9841 sv.ResourceOwner = ptr.String(jtv) 9842 } 9843 9844 case "version": 9845 if value != nil { 9846 jtv, ok := value.(json.Number) 9847 if !ok { 9848 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 9849 } 9850 i64, err := jtv.Int64() 9851 if err != nil { 9852 return err 9853 } 9854 sv.Version = ptr.Int64(i64) 9855 } 9856 9857 default: 9858 _, _ = key, value 9859 9860 } 9861 } 9862 *v = sv 9863 return nil 9864} 9865 9866func awsRestjson1_deserializeDocumentMeshSpec(v **types.MeshSpec, value interface{}) error { 9867 if v == nil { 9868 return fmt.Errorf("unexpected nil of type %T", v) 9869 } 9870 if value == nil { 9871 return nil 9872 } 9873 9874 shape, ok := value.(map[string]interface{}) 9875 if !ok { 9876 return fmt.Errorf("unexpected JSON type %v", value) 9877 } 9878 9879 var sv *types.MeshSpec 9880 if *v == nil { 9881 sv = &types.MeshSpec{} 9882 } else { 9883 sv = *v 9884 } 9885 9886 for key, value := range shape { 9887 switch key { 9888 case "egressFilter": 9889 if err := awsRestjson1_deserializeDocumentEgressFilter(&sv.EgressFilter, value); err != nil { 9890 return err 9891 } 9892 9893 default: 9894 _, _ = key, value 9895 9896 } 9897 } 9898 *v = sv 9899 return nil 9900} 9901 9902func awsRestjson1_deserializeDocumentMeshStatus(v **types.MeshStatus, value interface{}) error { 9903 if v == nil { 9904 return fmt.Errorf("unexpected nil of type %T", v) 9905 } 9906 if value == nil { 9907 return nil 9908 } 9909 9910 shape, ok := value.(map[string]interface{}) 9911 if !ok { 9912 return fmt.Errorf("unexpected JSON type %v", value) 9913 } 9914 9915 var sv *types.MeshStatus 9916 if *v == nil { 9917 sv = &types.MeshStatus{} 9918 } else { 9919 sv = *v 9920 } 9921 9922 for key, value := range shape { 9923 switch key { 9924 case "status": 9925 if value != nil { 9926 jtv, ok := value.(string) 9927 if !ok { 9928 return fmt.Errorf("expected MeshStatusCode to be of type string, got %T instead", value) 9929 } 9930 sv.Status = types.MeshStatusCode(jtv) 9931 } 9932 9933 default: 9934 _, _ = key, value 9935 9936 } 9937 } 9938 *v = sv 9939 return nil 9940} 9941 9942func awsRestjson1_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 9943 if v == nil { 9944 return fmt.Errorf("unexpected nil of type %T", v) 9945 } 9946 if value == nil { 9947 return nil 9948 } 9949 9950 shape, ok := value.(map[string]interface{}) 9951 if !ok { 9952 return fmt.Errorf("unexpected JSON type %v", value) 9953 } 9954 9955 var sv *types.NotFoundException 9956 if *v == nil { 9957 sv = &types.NotFoundException{} 9958 } else { 9959 sv = *v 9960 } 9961 9962 for key, value := range shape { 9963 switch key { 9964 case "message": 9965 if value != nil { 9966 jtv, ok := value.(string) 9967 if !ok { 9968 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9969 } 9970 sv.Message = ptr.String(jtv) 9971 } 9972 9973 default: 9974 _, _ = key, value 9975 9976 } 9977 } 9978 *v = sv 9979 return nil 9980} 9981 9982func awsRestjson1_deserializeDocumentOutlierDetection(v **types.OutlierDetection, value interface{}) error { 9983 if v == nil { 9984 return fmt.Errorf("unexpected nil of type %T", v) 9985 } 9986 if value == nil { 9987 return nil 9988 } 9989 9990 shape, ok := value.(map[string]interface{}) 9991 if !ok { 9992 return fmt.Errorf("unexpected JSON type %v", value) 9993 } 9994 9995 var sv *types.OutlierDetection 9996 if *v == nil { 9997 sv = &types.OutlierDetection{} 9998 } else { 9999 sv = *v 10000 } 10001 10002 for key, value := range shape { 10003 switch key { 10004 case "baseEjectionDuration": 10005 if err := awsRestjson1_deserializeDocumentDuration(&sv.BaseEjectionDuration, value); err != nil { 10006 return err 10007 } 10008 10009 case "interval": 10010 if err := awsRestjson1_deserializeDocumentDuration(&sv.Interval, value); err != nil { 10011 return err 10012 } 10013 10014 case "maxEjectionPercent": 10015 if value != nil { 10016 jtv, ok := value.(json.Number) 10017 if !ok { 10018 return fmt.Errorf("expected OutlierDetectionMaxEjectionPercent to be json.Number, got %T instead", value) 10019 } 10020 i64, err := jtv.Int64() 10021 if err != nil { 10022 return err 10023 } 10024 sv.MaxEjectionPercent = ptr.Int32(int32(i64)) 10025 } 10026 10027 case "maxServerErrors": 10028 if value != nil { 10029 jtv, ok := value.(json.Number) 10030 if !ok { 10031 return fmt.Errorf("expected OutlierDetectionMaxServerErrors to be json.Number, got %T instead", value) 10032 } 10033 i64, err := jtv.Int64() 10034 if err != nil { 10035 return err 10036 } 10037 sv.MaxServerErrors = ptr.Int64(i64) 10038 } 10039 10040 default: 10041 _, _ = key, value 10042 10043 } 10044 } 10045 *v = sv 10046 return nil 10047} 10048 10049func awsRestjson1_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error { 10050 if v == nil { 10051 return fmt.Errorf("unexpected nil of type %T", v) 10052 } 10053 if value == nil { 10054 return nil 10055 } 10056 10057 shape, ok := value.(map[string]interface{}) 10058 if !ok { 10059 return fmt.Errorf("unexpected JSON type %v", value) 10060 } 10061 10062 var sv *types.PortMapping 10063 if *v == nil { 10064 sv = &types.PortMapping{} 10065 } else { 10066 sv = *v 10067 } 10068 10069 for key, value := range shape { 10070 switch key { 10071 case "port": 10072 if value != nil { 10073 jtv, ok := value.(json.Number) 10074 if !ok { 10075 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 10076 } 10077 i64, err := jtv.Int64() 10078 if err != nil { 10079 return err 10080 } 10081 sv.Port = int32(i64) 10082 } 10083 10084 case "protocol": 10085 if value != nil { 10086 jtv, ok := value.(string) 10087 if !ok { 10088 return fmt.Errorf("expected PortProtocol to be of type string, got %T instead", value) 10089 } 10090 sv.Protocol = types.PortProtocol(jtv) 10091 } 10092 10093 default: 10094 _, _ = key, value 10095 10096 } 10097 } 10098 *v = sv 10099 return nil 10100} 10101 10102func awsRestjson1_deserializeDocumentPortSet(v *[]int32, value interface{}) error { 10103 if v == nil { 10104 return fmt.Errorf("unexpected nil of type %T", v) 10105 } 10106 if value == nil { 10107 return nil 10108 } 10109 10110 shape, ok := value.([]interface{}) 10111 if !ok { 10112 return fmt.Errorf("unexpected JSON type %v", value) 10113 } 10114 10115 var cv []int32 10116 if *v == nil { 10117 cv = []int32{} 10118 } else { 10119 cv = *v 10120 } 10121 10122 for _, value := range shape { 10123 var col int32 10124 if value != nil { 10125 jtv, ok := value.(json.Number) 10126 if !ok { 10127 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 10128 } 10129 i64, err := jtv.Int64() 10130 if err != nil { 10131 return err 10132 } 10133 col = int32(i64) 10134 } 10135 cv = append(cv, col) 10136 10137 } 10138 *v = cv 10139 return nil 10140} 10141 10142func awsRestjson1_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 10143 if v == nil { 10144 return fmt.Errorf("unexpected nil of type %T", v) 10145 } 10146 if value == nil { 10147 return nil 10148 } 10149 10150 shape, ok := value.(map[string]interface{}) 10151 if !ok { 10152 return fmt.Errorf("unexpected JSON type %v", value) 10153 } 10154 10155 var sv *types.ResourceInUseException 10156 if *v == nil { 10157 sv = &types.ResourceInUseException{} 10158 } else { 10159 sv = *v 10160 } 10161 10162 for key, value := range shape { 10163 switch key { 10164 case "message": 10165 if value != nil { 10166 jtv, ok := value.(string) 10167 if !ok { 10168 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10169 } 10170 sv.Message = ptr.String(jtv) 10171 } 10172 10173 default: 10174 _, _ = key, value 10175 10176 } 10177 } 10178 *v = sv 10179 return nil 10180} 10181 10182func awsRestjson1_deserializeDocumentResourceMetadata(v **types.ResourceMetadata, value interface{}) error { 10183 if v == nil { 10184 return fmt.Errorf("unexpected nil of type %T", v) 10185 } 10186 if value == nil { 10187 return nil 10188 } 10189 10190 shape, ok := value.(map[string]interface{}) 10191 if !ok { 10192 return fmt.Errorf("unexpected JSON type %v", value) 10193 } 10194 10195 var sv *types.ResourceMetadata 10196 if *v == nil { 10197 sv = &types.ResourceMetadata{} 10198 } else { 10199 sv = *v 10200 } 10201 10202 for key, value := range shape { 10203 switch key { 10204 case "arn": 10205 if value != nil { 10206 jtv, ok := value.(string) 10207 if !ok { 10208 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10209 } 10210 sv.Arn = ptr.String(jtv) 10211 } 10212 10213 case "createdAt": 10214 if value != nil { 10215 jtv, ok := value.(json.Number) 10216 if !ok { 10217 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10218 } 10219 f64, err := jtv.Float64() 10220 if err != nil { 10221 return err 10222 } 10223 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10224 } 10225 10226 case "lastUpdatedAt": 10227 if value != nil { 10228 jtv, ok := value.(json.Number) 10229 if !ok { 10230 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10231 } 10232 f64, err := jtv.Float64() 10233 if err != nil { 10234 return err 10235 } 10236 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10237 } 10238 10239 case "meshOwner": 10240 if value != nil { 10241 jtv, ok := value.(string) 10242 if !ok { 10243 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10244 } 10245 sv.MeshOwner = ptr.String(jtv) 10246 } 10247 10248 case "resourceOwner": 10249 if value != nil { 10250 jtv, ok := value.(string) 10251 if !ok { 10252 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10253 } 10254 sv.ResourceOwner = ptr.String(jtv) 10255 } 10256 10257 case "uid": 10258 if value != nil { 10259 jtv, ok := value.(string) 10260 if !ok { 10261 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10262 } 10263 sv.Uid = ptr.String(jtv) 10264 } 10265 10266 case "version": 10267 if value != nil { 10268 jtv, ok := value.(json.Number) 10269 if !ok { 10270 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10271 } 10272 i64, err := jtv.Int64() 10273 if err != nil { 10274 return err 10275 } 10276 sv.Version = ptr.Int64(i64) 10277 } 10278 10279 default: 10280 _, _ = key, value 10281 10282 } 10283 } 10284 *v = sv 10285 return nil 10286} 10287 10288func awsRestjson1_deserializeDocumentRouteData(v **types.RouteData, value interface{}) error { 10289 if v == nil { 10290 return fmt.Errorf("unexpected nil of type %T", v) 10291 } 10292 if value == nil { 10293 return nil 10294 } 10295 10296 shape, ok := value.(map[string]interface{}) 10297 if !ok { 10298 return fmt.Errorf("unexpected JSON type %v", value) 10299 } 10300 10301 var sv *types.RouteData 10302 if *v == nil { 10303 sv = &types.RouteData{} 10304 } else { 10305 sv = *v 10306 } 10307 10308 for key, value := range shape { 10309 switch key { 10310 case "meshName": 10311 if value != nil { 10312 jtv, ok := value.(string) 10313 if !ok { 10314 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10315 } 10316 sv.MeshName = ptr.String(jtv) 10317 } 10318 10319 case "metadata": 10320 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 10321 return err 10322 } 10323 10324 case "routeName": 10325 if value != nil { 10326 jtv, ok := value.(string) 10327 if !ok { 10328 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10329 } 10330 sv.RouteName = ptr.String(jtv) 10331 } 10332 10333 case "spec": 10334 if err := awsRestjson1_deserializeDocumentRouteSpec(&sv.Spec, value); err != nil { 10335 return err 10336 } 10337 10338 case "status": 10339 if err := awsRestjson1_deserializeDocumentRouteStatus(&sv.Status, value); err != nil { 10340 return err 10341 } 10342 10343 case "virtualRouterName": 10344 if value != nil { 10345 jtv, ok := value.(string) 10346 if !ok { 10347 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10348 } 10349 sv.VirtualRouterName = ptr.String(jtv) 10350 } 10351 10352 default: 10353 _, _ = key, value 10354 10355 } 10356 } 10357 *v = sv 10358 return nil 10359} 10360 10361func awsRestjson1_deserializeDocumentRouteList(v *[]types.RouteRef, value interface{}) error { 10362 if v == nil { 10363 return fmt.Errorf("unexpected nil of type %T", v) 10364 } 10365 if value == nil { 10366 return nil 10367 } 10368 10369 shape, ok := value.([]interface{}) 10370 if !ok { 10371 return fmt.Errorf("unexpected JSON type %v", value) 10372 } 10373 10374 var cv []types.RouteRef 10375 if *v == nil { 10376 cv = []types.RouteRef{} 10377 } else { 10378 cv = *v 10379 } 10380 10381 for _, value := range shape { 10382 var col types.RouteRef 10383 destAddr := &col 10384 if err := awsRestjson1_deserializeDocumentRouteRef(&destAddr, value); err != nil { 10385 return err 10386 } 10387 col = *destAddr 10388 cv = append(cv, col) 10389 10390 } 10391 *v = cv 10392 return nil 10393} 10394 10395func awsRestjson1_deserializeDocumentRouteRef(v **types.RouteRef, value interface{}) error { 10396 if v == nil { 10397 return fmt.Errorf("unexpected nil of type %T", v) 10398 } 10399 if value == nil { 10400 return nil 10401 } 10402 10403 shape, ok := value.(map[string]interface{}) 10404 if !ok { 10405 return fmt.Errorf("unexpected JSON type %v", value) 10406 } 10407 10408 var sv *types.RouteRef 10409 if *v == nil { 10410 sv = &types.RouteRef{} 10411 } else { 10412 sv = *v 10413 } 10414 10415 for key, value := range shape { 10416 switch key { 10417 case "arn": 10418 if value != nil { 10419 jtv, ok := value.(string) 10420 if !ok { 10421 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10422 } 10423 sv.Arn = ptr.String(jtv) 10424 } 10425 10426 case "createdAt": 10427 if value != nil { 10428 jtv, ok := value.(json.Number) 10429 if !ok { 10430 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10431 } 10432 f64, err := jtv.Float64() 10433 if err != nil { 10434 return err 10435 } 10436 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10437 } 10438 10439 case "lastUpdatedAt": 10440 if value != nil { 10441 jtv, ok := value.(json.Number) 10442 if !ok { 10443 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10444 } 10445 f64, err := jtv.Float64() 10446 if err != nil { 10447 return err 10448 } 10449 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10450 } 10451 10452 case "meshName": 10453 if value != nil { 10454 jtv, ok := value.(string) 10455 if !ok { 10456 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10457 } 10458 sv.MeshName = ptr.String(jtv) 10459 } 10460 10461 case "meshOwner": 10462 if value != nil { 10463 jtv, ok := value.(string) 10464 if !ok { 10465 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10466 } 10467 sv.MeshOwner = ptr.String(jtv) 10468 } 10469 10470 case "resourceOwner": 10471 if value != nil { 10472 jtv, ok := value.(string) 10473 if !ok { 10474 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10475 } 10476 sv.ResourceOwner = ptr.String(jtv) 10477 } 10478 10479 case "routeName": 10480 if value != nil { 10481 jtv, ok := value.(string) 10482 if !ok { 10483 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10484 } 10485 sv.RouteName = ptr.String(jtv) 10486 } 10487 10488 case "version": 10489 if value != nil { 10490 jtv, ok := value.(json.Number) 10491 if !ok { 10492 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10493 } 10494 i64, err := jtv.Int64() 10495 if err != nil { 10496 return err 10497 } 10498 sv.Version = ptr.Int64(i64) 10499 } 10500 10501 case "virtualRouterName": 10502 if value != nil { 10503 jtv, ok := value.(string) 10504 if !ok { 10505 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10506 } 10507 sv.VirtualRouterName = ptr.String(jtv) 10508 } 10509 10510 default: 10511 _, _ = key, value 10512 10513 } 10514 } 10515 *v = sv 10516 return nil 10517} 10518 10519func awsRestjson1_deserializeDocumentRouteSpec(v **types.RouteSpec, value interface{}) error { 10520 if v == nil { 10521 return fmt.Errorf("unexpected nil of type %T", v) 10522 } 10523 if value == nil { 10524 return nil 10525 } 10526 10527 shape, ok := value.(map[string]interface{}) 10528 if !ok { 10529 return fmt.Errorf("unexpected JSON type %v", value) 10530 } 10531 10532 var sv *types.RouteSpec 10533 if *v == nil { 10534 sv = &types.RouteSpec{} 10535 } else { 10536 sv = *v 10537 } 10538 10539 for key, value := range shape { 10540 switch key { 10541 case "grpcRoute": 10542 if err := awsRestjson1_deserializeDocumentGrpcRoute(&sv.GrpcRoute, value); err != nil { 10543 return err 10544 } 10545 10546 case "http2Route": 10547 if err := awsRestjson1_deserializeDocumentHttpRoute(&sv.Http2Route, value); err != nil { 10548 return err 10549 } 10550 10551 case "httpRoute": 10552 if err := awsRestjson1_deserializeDocumentHttpRoute(&sv.HttpRoute, value); err != nil { 10553 return err 10554 } 10555 10556 case "priority": 10557 if value != nil { 10558 jtv, ok := value.(json.Number) 10559 if !ok { 10560 return fmt.Errorf("expected RoutePriority to be json.Number, got %T instead", value) 10561 } 10562 i64, err := jtv.Int64() 10563 if err != nil { 10564 return err 10565 } 10566 sv.Priority = ptr.Int32(int32(i64)) 10567 } 10568 10569 case "tcpRoute": 10570 if err := awsRestjson1_deserializeDocumentTcpRoute(&sv.TcpRoute, value); err != nil { 10571 return err 10572 } 10573 10574 default: 10575 _, _ = key, value 10576 10577 } 10578 } 10579 *v = sv 10580 return nil 10581} 10582 10583func awsRestjson1_deserializeDocumentRouteStatus(v **types.RouteStatus, value interface{}) error { 10584 if v == nil { 10585 return fmt.Errorf("unexpected nil of type %T", v) 10586 } 10587 if value == nil { 10588 return nil 10589 } 10590 10591 shape, ok := value.(map[string]interface{}) 10592 if !ok { 10593 return fmt.Errorf("unexpected JSON type %v", value) 10594 } 10595 10596 var sv *types.RouteStatus 10597 if *v == nil { 10598 sv = &types.RouteStatus{} 10599 } else { 10600 sv = *v 10601 } 10602 10603 for key, value := range shape { 10604 switch key { 10605 case "status": 10606 if value != nil { 10607 jtv, ok := value.(string) 10608 if !ok { 10609 return fmt.Errorf("expected RouteStatusCode to be of type string, got %T instead", value) 10610 } 10611 sv.Status = types.RouteStatusCode(jtv) 10612 } 10613 10614 default: 10615 _, _ = key, value 10616 10617 } 10618 } 10619 *v = sv 10620 return nil 10621} 10622 10623func awsRestjson1_deserializeDocumentServiceDiscovery(v *types.ServiceDiscovery, value interface{}) error { 10624 if v == nil { 10625 return fmt.Errorf("unexpected nil of type %T", v) 10626 } 10627 if value == nil { 10628 return nil 10629 } 10630 10631 shape, ok := value.(map[string]interface{}) 10632 if !ok { 10633 return fmt.Errorf("unexpected JSON type %v", value) 10634 } 10635 10636 var uv types.ServiceDiscovery 10637loop: 10638 for key, value := range shape { 10639 if value == nil { 10640 continue 10641 } 10642 switch key { 10643 case "awsCloudMap": 10644 var mv types.AwsCloudMapServiceDiscovery 10645 destAddr := &mv 10646 if err := awsRestjson1_deserializeDocumentAwsCloudMapServiceDiscovery(&destAddr, value); err != nil { 10647 return err 10648 } 10649 mv = *destAddr 10650 uv = &types.ServiceDiscoveryMemberAwsCloudMap{Value: mv} 10651 break loop 10652 10653 case "dns": 10654 var mv types.DnsServiceDiscovery 10655 destAddr := &mv 10656 if err := awsRestjson1_deserializeDocumentDnsServiceDiscovery(&destAddr, value); err != nil { 10657 return err 10658 } 10659 mv = *destAddr 10660 uv = &types.ServiceDiscoveryMemberDns{Value: mv} 10661 break loop 10662 10663 default: 10664 uv = &types.UnknownUnionMember{Tag: key} 10665 break loop 10666 10667 } 10668 } 10669 *v = uv 10670 return nil 10671} 10672 10673func awsRestjson1_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { 10674 if v == nil { 10675 return fmt.Errorf("unexpected nil of type %T", v) 10676 } 10677 if value == nil { 10678 return nil 10679 } 10680 10681 shape, ok := value.(map[string]interface{}) 10682 if !ok { 10683 return fmt.Errorf("unexpected JSON type %v", value) 10684 } 10685 10686 var sv *types.ServiceUnavailableException 10687 if *v == nil { 10688 sv = &types.ServiceUnavailableException{} 10689 } else { 10690 sv = *v 10691 } 10692 10693 for key, value := range shape { 10694 switch key { 10695 case "message": 10696 if value != nil { 10697 jtv, ok := value.(string) 10698 if !ok { 10699 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10700 } 10701 sv.Message = ptr.String(jtv) 10702 } 10703 10704 default: 10705 _, _ = key, value 10706 10707 } 10708 } 10709 *v = sv 10710 return nil 10711} 10712 10713func awsRestjson1_deserializeDocumentSubjectAlternativeNameList(v *[]string, value interface{}) error { 10714 if v == nil { 10715 return fmt.Errorf("unexpected nil of type %T", v) 10716 } 10717 if value == nil { 10718 return nil 10719 } 10720 10721 shape, ok := value.([]interface{}) 10722 if !ok { 10723 return fmt.Errorf("unexpected JSON type %v", value) 10724 } 10725 10726 var cv []string 10727 if *v == nil { 10728 cv = []string{} 10729 } else { 10730 cv = *v 10731 } 10732 10733 for _, value := range shape { 10734 var col string 10735 if value != nil { 10736 jtv, ok := value.(string) 10737 if !ok { 10738 return fmt.Errorf("expected SubjectAlternativeName to be of type string, got %T instead", value) 10739 } 10740 col = jtv 10741 } 10742 cv = append(cv, col) 10743 10744 } 10745 *v = cv 10746 return nil 10747} 10748 10749func awsRestjson1_deserializeDocumentSubjectAlternativeNameMatchers(v **types.SubjectAlternativeNameMatchers, value interface{}) error { 10750 if v == nil { 10751 return fmt.Errorf("unexpected nil of type %T", v) 10752 } 10753 if value == nil { 10754 return nil 10755 } 10756 10757 shape, ok := value.(map[string]interface{}) 10758 if !ok { 10759 return fmt.Errorf("unexpected JSON type %v", value) 10760 } 10761 10762 var sv *types.SubjectAlternativeNameMatchers 10763 if *v == nil { 10764 sv = &types.SubjectAlternativeNameMatchers{} 10765 } else { 10766 sv = *v 10767 } 10768 10769 for key, value := range shape { 10770 switch key { 10771 case "exact": 10772 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNameList(&sv.Exact, value); err != nil { 10773 return err 10774 } 10775 10776 default: 10777 _, _ = key, value 10778 10779 } 10780 } 10781 *v = sv 10782 return nil 10783} 10784 10785func awsRestjson1_deserializeDocumentSubjectAlternativeNames(v **types.SubjectAlternativeNames, value interface{}) error { 10786 if v == nil { 10787 return fmt.Errorf("unexpected nil of type %T", v) 10788 } 10789 if value == nil { 10790 return nil 10791 } 10792 10793 shape, ok := value.(map[string]interface{}) 10794 if !ok { 10795 return fmt.Errorf("unexpected JSON type %v", value) 10796 } 10797 10798 var sv *types.SubjectAlternativeNames 10799 if *v == nil { 10800 sv = &types.SubjectAlternativeNames{} 10801 } else { 10802 sv = *v 10803 } 10804 10805 for key, value := range shape { 10806 switch key { 10807 case "match": 10808 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNameMatchers(&sv.Match, value); err != nil { 10809 return err 10810 } 10811 10812 default: 10813 _, _ = key, value 10814 10815 } 10816 } 10817 *v = sv 10818 return nil 10819} 10820 10821func awsRestjson1_deserializeDocumentTagList(v *[]types.TagRef, value interface{}) error { 10822 if v == nil { 10823 return fmt.Errorf("unexpected nil of type %T", v) 10824 } 10825 if value == nil { 10826 return nil 10827 } 10828 10829 shape, ok := value.([]interface{}) 10830 if !ok { 10831 return fmt.Errorf("unexpected JSON type %v", value) 10832 } 10833 10834 var cv []types.TagRef 10835 if *v == nil { 10836 cv = []types.TagRef{} 10837 } else { 10838 cv = *v 10839 } 10840 10841 for _, value := range shape { 10842 var col types.TagRef 10843 destAddr := &col 10844 if err := awsRestjson1_deserializeDocumentTagRef(&destAddr, value); err != nil { 10845 return err 10846 } 10847 col = *destAddr 10848 cv = append(cv, col) 10849 10850 } 10851 *v = cv 10852 return nil 10853} 10854 10855func awsRestjson1_deserializeDocumentTagRef(v **types.TagRef, value interface{}) error { 10856 if v == nil { 10857 return fmt.Errorf("unexpected nil of type %T", v) 10858 } 10859 if value == nil { 10860 return nil 10861 } 10862 10863 shape, ok := value.(map[string]interface{}) 10864 if !ok { 10865 return fmt.Errorf("unexpected JSON type %v", value) 10866 } 10867 10868 var sv *types.TagRef 10869 if *v == nil { 10870 sv = &types.TagRef{} 10871 } else { 10872 sv = *v 10873 } 10874 10875 for key, value := range shape { 10876 switch key { 10877 case "key": 10878 if value != nil { 10879 jtv, ok := value.(string) 10880 if !ok { 10881 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 10882 } 10883 sv.Key = ptr.String(jtv) 10884 } 10885 10886 case "value": 10887 if value != nil { 10888 jtv, ok := value.(string) 10889 if !ok { 10890 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 10891 } 10892 sv.Value = ptr.String(jtv) 10893 } 10894 10895 default: 10896 _, _ = key, value 10897 10898 } 10899 } 10900 *v = sv 10901 return nil 10902} 10903 10904func awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(v *[]types.TcpRetryPolicyEvent, value interface{}) error { 10905 if v == nil { 10906 return fmt.Errorf("unexpected nil of type %T", v) 10907 } 10908 if value == nil { 10909 return nil 10910 } 10911 10912 shape, ok := value.([]interface{}) 10913 if !ok { 10914 return fmt.Errorf("unexpected JSON type %v", value) 10915 } 10916 10917 var cv []types.TcpRetryPolicyEvent 10918 if *v == nil { 10919 cv = []types.TcpRetryPolicyEvent{} 10920 } else { 10921 cv = *v 10922 } 10923 10924 for _, value := range shape { 10925 var col types.TcpRetryPolicyEvent 10926 if value != nil { 10927 jtv, ok := value.(string) 10928 if !ok { 10929 return fmt.Errorf("expected TcpRetryPolicyEvent to be of type string, got %T instead", value) 10930 } 10931 col = types.TcpRetryPolicyEvent(jtv) 10932 } 10933 cv = append(cv, col) 10934 10935 } 10936 *v = cv 10937 return nil 10938} 10939 10940func awsRestjson1_deserializeDocumentTcpRoute(v **types.TcpRoute, value interface{}) error { 10941 if v == nil { 10942 return fmt.Errorf("unexpected nil of type %T", v) 10943 } 10944 if value == nil { 10945 return nil 10946 } 10947 10948 shape, ok := value.(map[string]interface{}) 10949 if !ok { 10950 return fmt.Errorf("unexpected JSON type %v", value) 10951 } 10952 10953 var sv *types.TcpRoute 10954 if *v == nil { 10955 sv = &types.TcpRoute{} 10956 } else { 10957 sv = *v 10958 } 10959 10960 for key, value := range shape { 10961 switch key { 10962 case "action": 10963 if err := awsRestjson1_deserializeDocumentTcpRouteAction(&sv.Action, value); err != nil { 10964 return err 10965 } 10966 10967 case "timeout": 10968 if err := awsRestjson1_deserializeDocumentTcpTimeout(&sv.Timeout, value); err != nil { 10969 return err 10970 } 10971 10972 default: 10973 _, _ = key, value 10974 10975 } 10976 } 10977 *v = sv 10978 return nil 10979} 10980 10981func awsRestjson1_deserializeDocumentTcpRouteAction(v **types.TcpRouteAction, value interface{}) error { 10982 if v == nil { 10983 return fmt.Errorf("unexpected nil of type %T", v) 10984 } 10985 if value == nil { 10986 return nil 10987 } 10988 10989 shape, ok := value.(map[string]interface{}) 10990 if !ok { 10991 return fmt.Errorf("unexpected JSON type %v", value) 10992 } 10993 10994 var sv *types.TcpRouteAction 10995 if *v == nil { 10996 sv = &types.TcpRouteAction{} 10997 } else { 10998 sv = *v 10999 } 11000 11001 for key, value := range shape { 11002 switch key { 11003 case "weightedTargets": 11004 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 11005 return err 11006 } 11007 11008 default: 11009 _, _ = key, value 11010 11011 } 11012 } 11013 *v = sv 11014 return nil 11015} 11016 11017func awsRestjson1_deserializeDocumentTcpTimeout(v **types.TcpTimeout, value interface{}) error { 11018 if v == nil { 11019 return fmt.Errorf("unexpected nil of type %T", v) 11020 } 11021 if value == nil { 11022 return nil 11023 } 11024 11025 shape, ok := value.(map[string]interface{}) 11026 if !ok { 11027 return fmt.Errorf("unexpected JSON type %v", value) 11028 } 11029 11030 var sv *types.TcpTimeout 11031 if *v == nil { 11032 sv = &types.TcpTimeout{} 11033 } else { 11034 sv = *v 11035 } 11036 11037 for key, value := range shape { 11038 switch key { 11039 case "idle": 11040 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 11041 return err 11042 } 11043 11044 default: 11045 _, _ = key, value 11046 11047 } 11048 } 11049 *v = sv 11050 return nil 11051} 11052 11053func awsRestjson1_deserializeDocumentTlsValidationContext(v **types.TlsValidationContext, value interface{}) error { 11054 if v == nil { 11055 return fmt.Errorf("unexpected nil of type %T", v) 11056 } 11057 if value == nil { 11058 return nil 11059 } 11060 11061 shape, ok := value.(map[string]interface{}) 11062 if !ok { 11063 return fmt.Errorf("unexpected JSON type %v", value) 11064 } 11065 11066 var sv *types.TlsValidationContext 11067 if *v == nil { 11068 sv = &types.TlsValidationContext{} 11069 } else { 11070 sv = *v 11071 } 11072 11073 for key, value := range shape { 11074 switch key { 11075 case "subjectAlternativeNames": 11076 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 11077 return err 11078 } 11079 11080 case "trust": 11081 if err := awsRestjson1_deserializeDocumentTlsValidationContextTrust(&sv.Trust, value); err != nil { 11082 return err 11083 } 11084 11085 default: 11086 _, _ = key, value 11087 11088 } 11089 } 11090 *v = sv 11091 return nil 11092} 11093 11094func awsRestjson1_deserializeDocumentTlsValidationContextAcmTrust(v **types.TlsValidationContextAcmTrust, value interface{}) error { 11095 if v == nil { 11096 return fmt.Errorf("unexpected nil of type %T", v) 11097 } 11098 if value == nil { 11099 return nil 11100 } 11101 11102 shape, ok := value.(map[string]interface{}) 11103 if !ok { 11104 return fmt.Errorf("unexpected JSON type %v", value) 11105 } 11106 11107 var sv *types.TlsValidationContextAcmTrust 11108 if *v == nil { 11109 sv = &types.TlsValidationContextAcmTrust{} 11110 } else { 11111 sv = *v 11112 } 11113 11114 for key, value := range shape { 11115 switch key { 11116 case "certificateAuthorityArns": 11117 if err := awsRestjson1_deserializeDocumentCertificateAuthorityArns(&sv.CertificateAuthorityArns, value); err != nil { 11118 return err 11119 } 11120 11121 default: 11122 _, _ = key, value 11123 11124 } 11125 } 11126 *v = sv 11127 return nil 11128} 11129 11130func awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(v **types.TlsValidationContextFileTrust, value interface{}) error { 11131 if v == nil { 11132 return fmt.Errorf("unexpected nil of type %T", v) 11133 } 11134 if value == nil { 11135 return nil 11136 } 11137 11138 shape, ok := value.(map[string]interface{}) 11139 if !ok { 11140 return fmt.Errorf("unexpected JSON type %v", value) 11141 } 11142 11143 var sv *types.TlsValidationContextFileTrust 11144 if *v == nil { 11145 sv = &types.TlsValidationContextFileTrust{} 11146 } else { 11147 sv = *v 11148 } 11149 11150 for key, value := range shape { 11151 switch key { 11152 case "certificateChain": 11153 if value != nil { 11154 jtv, ok := value.(string) 11155 if !ok { 11156 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 11157 } 11158 sv.CertificateChain = ptr.String(jtv) 11159 } 11160 11161 default: 11162 _, _ = key, value 11163 11164 } 11165 } 11166 *v = sv 11167 return nil 11168} 11169 11170func awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(v **types.TlsValidationContextSdsTrust, value interface{}) error { 11171 if v == nil { 11172 return fmt.Errorf("unexpected nil of type %T", v) 11173 } 11174 if value == nil { 11175 return nil 11176 } 11177 11178 shape, ok := value.(map[string]interface{}) 11179 if !ok { 11180 return fmt.Errorf("unexpected JSON type %v", value) 11181 } 11182 11183 var sv *types.TlsValidationContextSdsTrust 11184 if *v == nil { 11185 sv = &types.TlsValidationContextSdsTrust{} 11186 } else { 11187 sv = *v 11188 } 11189 11190 for key, value := range shape { 11191 switch key { 11192 case "secretName": 11193 if value != nil { 11194 jtv, ok := value.(string) 11195 if !ok { 11196 return fmt.Errorf("expected SdsSecretName to be of type string, got %T instead", value) 11197 } 11198 sv.SecretName = ptr.String(jtv) 11199 } 11200 11201 default: 11202 _, _ = key, value 11203 11204 } 11205 } 11206 *v = sv 11207 return nil 11208} 11209 11210func awsRestjson1_deserializeDocumentTlsValidationContextTrust(v *types.TlsValidationContextTrust, value interface{}) error { 11211 if v == nil { 11212 return fmt.Errorf("unexpected nil of type %T", v) 11213 } 11214 if value == nil { 11215 return nil 11216 } 11217 11218 shape, ok := value.(map[string]interface{}) 11219 if !ok { 11220 return fmt.Errorf("unexpected JSON type %v", value) 11221 } 11222 11223 var uv types.TlsValidationContextTrust 11224loop: 11225 for key, value := range shape { 11226 if value == nil { 11227 continue 11228 } 11229 switch key { 11230 case "acm": 11231 var mv types.TlsValidationContextAcmTrust 11232 destAddr := &mv 11233 if err := awsRestjson1_deserializeDocumentTlsValidationContextAcmTrust(&destAddr, value); err != nil { 11234 return err 11235 } 11236 mv = *destAddr 11237 uv = &types.TlsValidationContextTrustMemberAcm{Value: mv} 11238 break loop 11239 11240 case "file": 11241 var mv types.TlsValidationContextFileTrust 11242 destAddr := &mv 11243 if err := awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(&destAddr, value); err != nil { 11244 return err 11245 } 11246 mv = *destAddr 11247 uv = &types.TlsValidationContextTrustMemberFile{Value: mv} 11248 break loop 11249 11250 case "sds": 11251 var mv types.TlsValidationContextSdsTrust 11252 destAddr := &mv 11253 if err := awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(&destAddr, value); err != nil { 11254 return err 11255 } 11256 mv = *destAddr 11257 uv = &types.TlsValidationContextTrustMemberSds{Value: mv} 11258 break loop 11259 11260 default: 11261 uv = &types.UnknownUnionMember{Tag: key} 11262 break loop 11263 11264 } 11265 } 11266 *v = uv 11267 return nil 11268} 11269 11270func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 11271 if v == nil { 11272 return fmt.Errorf("unexpected nil of type %T", v) 11273 } 11274 if value == nil { 11275 return nil 11276 } 11277 11278 shape, ok := value.(map[string]interface{}) 11279 if !ok { 11280 return fmt.Errorf("unexpected JSON type %v", value) 11281 } 11282 11283 var sv *types.TooManyRequestsException 11284 if *v == nil { 11285 sv = &types.TooManyRequestsException{} 11286 } else { 11287 sv = *v 11288 } 11289 11290 for key, value := range shape { 11291 switch key { 11292 case "message": 11293 if value != nil { 11294 jtv, ok := value.(string) 11295 if !ok { 11296 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11297 } 11298 sv.Message = ptr.String(jtv) 11299 } 11300 11301 default: 11302 _, _ = key, value 11303 11304 } 11305 } 11306 *v = sv 11307 return nil 11308} 11309 11310func awsRestjson1_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 11311 if v == nil { 11312 return fmt.Errorf("unexpected nil of type %T", v) 11313 } 11314 if value == nil { 11315 return nil 11316 } 11317 11318 shape, ok := value.(map[string]interface{}) 11319 if !ok { 11320 return fmt.Errorf("unexpected JSON type %v", value) 11321 } 11322 11323 var sv *types.TooManyTagsException 11324 if *v == nil { 11325 sv = &types.TooManyTagsException{} 11326 } else { 11327 sv = *v 11328 } 11329 11330 for key, value := range shape { 11331 switch key { 11332 case "message": 11333 if value != nil { 11334 jtv, ok := value.(string) 11335 if !ok { 11336 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11337 } 11338 sv.Message = ptr.String(jtv) 11339 } 11340 11341 default: 11342 _, _ = key, value 11343 11344 } 11345 } 11346 *v = sv 11347 return nil 11348} 11349 11350func awsRestjson1_deserializeDocumentVirtualGatewayAccessLog(v *types.VirtualGatewayAccessLog, value interface{}) error { 11351 if v == nil { 11352 return fmt.Errorf("unexpected nil of type %T", v) 11353 } 11354 if value == nil { 11355 return nil 11356 } 11357 11358 shape, ok := value.(map[string]interface{}) 11359 if !ok { 11360 return fmt.Errorf("unexpected JSON type %v", value) 11361 } 11362 11363 var uv types.VirtualGatewayAccessLog 11364loop: 11365 for key, value := range shape { 11366 if value == nil { 11367 continue 11368 } 11369 switch key { 11370 case "file": 11371 var mv types.VirtualGatewayFileAccessLog 11372 destAddr := &mv 11373 if err := awsRestjson1_deserializeDocumentVirtualGatewayFileAccessLog(&destAddr, value); err != nil { 11374 return err 11375 } 11376 mv = *destAddr 11377 uv = &types.VirtualGatewayAccessLogMemberFile{Value: mv} 11378 break loop 11379 11380 default: 11381 uv = &types.UnknownUnionMember{Tag: key} 11382 break loop 11383 11384 } 11385 } 11386 *v = uv 11387 return nil 11388} 11389 11390func awsRestjson1_deserializeDocumentVirtualGatewayBackendDefaults(v **types.VirtualGatewayBackendDefaults, value interface{}) error { 11391 if v == nil { 11392 return fmt.Errorf("unexpected nil of type %T", v) 11393 } 11394 if value == nil { 11395 return nil 11396 } 11397 11398 shape, ok := value.(map[string]interface{}) 11399 if !ok { 11400 return fmt.Errorf("unexpected JSON type %v", value) 11401 } 11402 11403 var sv *types.VirtualGatewayBackendDefaults 11404 if *v == nil { 11405 sv = &types.VirtualGatewayBackendDefaults{} 11406 } else { 11407 sv = *v 11408 } 11409 11410 for key, value := range shape { 11411 switch key { 11412 case "clientPolicy": 11413 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientPolicy(&sv.ClientPolicy, value); err != nil { 11414 return err 11415 } 11416 11417 default: 11418 _, _ = key, value 11419 11420 } 11421 } 11422 *v = sv 11423 return nil 11424} 11425 11426func awsRestjson1_deserializeDocumentVirtualGatewayCertificateAuthorityArns(v *[]string, value interface{}) error { 11427 if v == nil { 11428 return fmt.Errorf("unexpected nil of type %T", v) 11429 } 11430 if value == nil { 11431 return nil 11432 } 11433 11434 shape, ok := value.([]interface{}) 11435 if !ok { 11436 return fmt.Errorf("unexpected JSON type %v", value) 11437 } 11438 11439 var cv []string 11440 if *v == nil { 11441 cv = []string{} 11442 } else { 11443 cv = *v 11444 } 11445 11446 for _, value := range shape { 11447 var col string 11448 if value != nil { 11449 jtv, ok := value.(string) 11450 if !ok { 11451 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 11452 } 11453 col = jtv 11454 } 11455 cv = append(cv, col) 11456 11457 } 11458 *v = cv 11459 return nil 11460} 11461 11462func awsRestjson1_deserializeDocumentVirtualGatewayClientPolicy(v **types.VirtualGatewayClientPolicy, value interface{}) error { 11463 if v == nil { 11464 return fmt.Errorf("unexpected nil of type %T", v) 11465 } 11466 if value == nil { 11467 return nil 11468 } 11469 11470 shape, ok := value.(map[string]interface{}) 11471 if !ok { 11472 return fmt.Errorf("unexpected JSON type %v", value) 11473 } 11474 11475 var sv *types.VirtualGatewayClientPolicy 11476 if *v == nil { 11477 sv = &types.VirtualGatewayClientPolicy{} 11478 } else { 11479 sv = *v 11480 } 11481 11482 for key, value := range shape { 11483 switch key { 11484 case "tls": 11485 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientPolicyTls(&sv.Tls, value); err != nil { 11486 return err 11487 } 11488 11489 default: 11490 _, _ = key, value 11491 11492 } 11493 } 11494 *v = sv 11495 return nil 11496} 11497 11498func awsRestjson1_deserializeDocumentVirtualGatewayClientPolicyTls(v **types.VirtualGatewayClientPolicyTls, value interface{}) error { 11499 if v == nil { 11500 return fmt.Errorf("unexpected nil of type %T", v) 11501 } 11502 if value == nil { 11503 return nil 11504 } 11505 11506 shape, ok := value.(map[string]interface{}) 11507 if !ok { 11508 return fmt.Errorf("unexpected JSON type %v", value) 11509 } 11510 11511 var sv *types.VirtualGatewayClientPolicyTls 11512 if *v == nil { 11513 sv = &types.VirtualGatewayClientPolicyTls{} 11514 } else { 11515 sv = *v 11516 } 11517 11518 for key, value := range shape { 11519 switch key { 11520 case "certificate": 11521 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientTlsCertificate(&sv.Certificate, value); err != nil { 11522 return err 11523 } 11524 11525 case "enforce": 11526 if value != nil { 11527 jtv, ok := value.(bool) 11528 if !ok { 11529 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11530 } 11531 sv.Enforce = ptr.Bool(jtv) 11532 } 11533 11534 case "ports": 11535 if err := awsRestjson1_deserializeDocumentPortSet(&sv.Ports, value); err != nil { 11536 return err 11537 } 11538 11539 case "validation": 11540 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContext(&sv.Validation, value); err != nil { 11541 return err 11542 } 11543 11544 default: 11545 _, _ = key, value 11546 11547 } 11548 } 11549 *v = sv 11550 return nil 11551} 11552 11553func awsRestjson1_deserializeDocumentVirtualGatewayClientTlsCertificate(v *types.VirtualGatewayClientTlsCertificate, value interface{}) error { 11554 if v == nil { 11555 return fmt.Errorf("unexpected nil of type %T", v) 11556 } 11557 if value == nil { 11558 return nil 11559 } 11560 11561 shape, ok := value.(map[string]interface{}) 11562 if !ok { 11563 return fmt.Errorf("unexpected JSON type %v", value) 11564 } 11565 11566 var uv types.VirtualGatewayClientTlsCertificate 11567loop: 11568 for key, value := range shape { 11569 if value == nil { 11570 continue 11571 } 11572 switch key { 11573 case "file": 11574 var mv types.VirtualGatewayListenerTlsFileCertificate 11575 destAddr := &mv 11576 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(&destAddr, value); err != nil { 11577 return err 11578 } 11579 mv = *destAddr 11580 uv = &types.VirtualGatewayClientTlsCertificateMemberFile{Value: mv} 11581 break loop 11582 11583 case "sds": 11584 var mv types.VirtualGatewayListenerTlsSdsCertificate 11585 destAddr := &mv 11586 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(&destAddr, value); err != nil { 11587 return err 11588 } 11589 mv = *destAddr 11590 uv = &types.VirtualGatewayClientTlsCertificateMemberSds{Value: mv} 11591 break loop 11592 11593 default: 11594 uv = &types.UnknownUnionMember{Tag: key} 11595 break loop 11596 11597 } 11598 } 11599 *v = uv 11600 return nil 11601} 11602 11603func awsRestjson1_deserializeDocumentVirtualGatewayConnectionPool(v *types.VirtualGatewayConnectionPool, value interface{}) error { 11604 if v == nil { 11605 return fmt.Errorf("unexpected nil of type %T", v) 11606 } 11607 if value == nil { 11608 return nil 11609 } 11610 11611 shape, ok := value.(map[string]interface{}) 11612 if !ok { 11613 return fmt.Errorf("unexpected JSON type %v", value) 11614 } 11615 11616 var uv types.VirtualGatewayConnectionPool 11617loop: 11618 for key, value := range shape { 11619 if value == nil { 11620 continue 11621 } 11622 switch key { 11623 case "grpc": 11624 var mv types.VirtualGatewayGrpcConnectionPool 11625 destAddr := &mv 11626 if err := awsRestjson1_deserializeDocumentVirtualGatewayGrpcConnectionPool(&destAddr, value); err != nil { 11627 return err 11628 } 11629 mv = *destAddr 11630 uv = &types.VirtualGatewayConnectionPoolMemberGrpc{Value: mv} 11631 break loop 11632 11633 case "http": 11634 var mv types.VirtualGatewayHttpConnectionPool 11635 destAddr := &mv 11636 if err := awsRestjson1_deserializeDocumentVirtualGatewayHttpConnectionPool(&destAddr, value); err != nil { 11637 return err 11638 } 11639 mv = *destAddr 11640 uv = &types.VirtualGatewayConnectionPoolMemberHttp{Value: mv} 11641 break loop 11642 11643 case "http2": 11644 var mv types.VirtualGatewayHttp2ConnectionPool 11645 destAddr := &mv 11646 if err := awsRestjson1_deserializeDocumentVirtualGatewayHttp2ConnectionPool(&destAddr, value); err != nil { 11647 return err 11648 } 11649 mv = *destAddr 11650 uv = &types.VirtualGatewayConnectionPoolMemberHttp2{Value: mv} 11651 break loop 11652 11653 default: 11654 uv = &types.UnknownUnionMember{Tag: key} 11655 break loop 11656 11657 } 11658 } 11659 *v = uv 11660 return nil 11661} 11662 11663func awsRestjson1_deserializeDocumentVirtualGatewayData(v **types.VirtualGatewayData, value interface{}) error { 11664 if v == nil { 11665 return fmt.Errorf("unexpected nil of type %T", v) 11666 } 11667 if value == nil { 11668 return nil 11669 } 11670 11671 shape, ok := value.(map[string]interface{}) 11672 if !ok { 11673 return fmt.Errorf("unexpected JSON type %v", value) 11674 } 11675 11676 var sv *types.VirtualGatewayData 11677 if *v == nil { 11678 sv = &types.VirtualGatewayData{} 11679 } else { 11680 sv = *v 11681 } 11682 11683 for key, value := range shape { 11684 switch key { 11685 case "meshName": 11686 if value != nil { 11687 jtv, ok := value.(string) 11688 if !ok { 11689 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11690 } 11691 sv.MeshName = ptr.String(jtv) 11692 } 11693 11694 case "metadata": 11695 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 11696 return err 11697 } 11698 11699 case "spec": 11700 if err := awsRestjson1_deserializeDocumentVirtualGatewaySpec(&sv.Spec, value); err != nil { 11701 return err 11702 } 11703 11704 case "status": 11705 if err := awsRestjson1_deserializeDocumentVirtualGatewayStatus(&sv.Status, value); err != nil { 11706 return err 11707 } 11708 11709 case "virtualGatewayName": 11710 if value != nil { 11711 jtv, ok := value.(string) 11712 if !ok { 11713 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11714 } 11715 sv.VirtualGatewayName = ptr.String(jtv) 11716 } 11717 11718 default: 11719 _, _ = key, value 11720 11721 } 11722 } 11723 *v = sv 11724 return nil 11725} 11726 11727func awsRestjson1_deserializeDocumentVirtualGatewayFileAccessLog(v **types.VirtualGatewayFileAccessLog, value interface{}) error { 11728 if v == nil { 11729 return fmt.Errorf("unexpected nil of type %T", v) 11730 } 11731 if value == nil { 11732 return nil 11733 } 11734 11735 shape, ok := value.(map[string]interface{}) 11736 if !ok { 11737 return fmt.Errorf("unexpected JSON type %v", value) 11738 } 11739 11740 var sv *types.VirtualGatewayFileAccessLog 11741 if *v == nil { 11742 sv = &types.VirtualGatewayFileAccessLog{} 11743 } else { 11744 sv = *v 11745 } 11746 11747 for key, value := range shape { 11748 switch key { 11749 case "path": 11750 if value != nil { 11751 jtv, ok := value.(string) 11752 if !ok { 11753 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 11754 } 11755 sv.Path = ptr.String(jtv) 11756 } 11757 11758 default: 11759 _, _ = key, value 11760 11761 } 11762 } 11763 *v = sv 11764 return nil 11765} 11766 11767func awsRestjson1_deserializeDocumentVirtualGatewayGrpcConnectionPool(v **types.VirtualGatewayGrpcConnectionPool, value interface{}) error { 11768 if v == nil { 11769 return fmt.Errorf("unexpected nil of type %T", v) 11770 } 11771 if value == nil { 11772 return nil 11773 } 11774 11775 shape, ok := value.(map[string]interface{}) 11776 if !ok { 11777 return fmt.Errorf("unexpected JSON type %v", value) 11778 } 11779 11780 var sv *types.VirtualGatewayGrpcConnectionPool 11781 if *v == nil { 11782 sv = &types.VirtualGatewayGrpcConnectionPool{} 11783 } else { 11784 sv = *v 11785 } 11786 11787 for key, value := range shape { 11788 switch key { 11789 case "maxRequests": 11790 if value != nil { 11791 jtv, ok := value.(json.Number) 11792 if !ok { 11793 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 11794 } 11795 i64, err := jtv.Int64() 11796 if err != nil { 11797 return err 11798 } 11799 sv.MaxRequests = int32(i64) 11800 } 11801 11802 default: 11803 _, _ = key, value 11804 11805 } 11806 } 11807 *v = sv 11808 return nil 11809} 11810 11811func awsRestjson1_deserializeDocumentVirtualGatewayHealthCheckPolicy(v **types.VirtualGatewayHealthCheckPolicy, value interface{}) error { 11812 if v == nil { 11813 return fmt.Errorf("unexpected nil of type %T", v) 11814 } 11815 if value == nil { 11816 return nil 11817 } 11818 11819 shape, ok := value.(map[string]interface{}) 11820 if !ok { 11821 return fmt.Errorf("unexpected JSON type %v", value) 11822 } 11823 11824 var sv *types.VirtualGatewayHealthCheckPolicy 11825 if *v == nil { 11826 sv = &types.VirtualGatewayHealthCheckPolicy{} 11827 } else { 11828 sv = *v 11829 } 11830 11831 for key, value := range shape { 11832 switch key { 11833 case "healthyThreshold": 11834 if value != nil { 11835 jtv, ok := value.(json.Number) 11836 if !ok { 11837 return fmt.Errorf("expected VirtualGatewayHealthCheckThreshold to be json.Number, got %T instead", value) 11838 } 11839 i64, err := jtv.Int64() 11840 if err != nil { 11841 return err 11842 } 11843 sv.HealthyThreshold = int32(i64) 11844 } 11845 11846 case "intervalMillis": 11847 if value != nil { 11848 jtv, ok := value.(json.Number) 11849 if !ok { 11850 return fmt.Errorf("expected VirtualGatewayHealthCheckIntervalMillis to be json.Number, got %T instead", value) 11851 } 11852 i64, err := jtv.Int64() 11853 if err != nil { 11854 return err 11855 } 11856 sv.IntervalMillis = ptr.Int64(i64) 11857 } 11858 11859 case "path": 11860 if value != nil { 11861 jtv, ok := value.(string) 11862 if !ok { 11863 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11864 } 11865 sv.Path = ptr.String(jtv) 11866 } 11867 11868 case "port": 11869 if value != nil { 11870 jtv, ok := value.(json.Number) 11871 if !ok { 11872 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 11873 } 11874 i64, err := jtv.Int64() 11875 if err != nil { 11876 return err 11877 } 11878 sv.Port = int32(i64) 11879 } 11880 11881 case "protocol": 11882 if value != nil { 11883 jtv, ok := value.(string) 11884 if !ok { 11885 return fmt.Errorf("expected VirtualGatewayPortProtocol to be of type string, got %T instead", value) 11886 } 11887 sv.Protocol = types.VirtualGatewayPortProtocol(jtv) 11888 } 11889 11890 case "timeoutMillis": 11891 if value != nil { 11892 jtv, ok := value.(json.Number) 11893 if !ok { 11894 return fmt.Errorf("expected VirtualGatewayHealthCheckTimeoutMillis to be json.Number, got %T instead", value) 11895 } 11896 i64, err := jtv.Int64() 11897 if err != nil { 11898 return err 11899 } 11900 sv.TimeoutMillis = ptr.Int64(i64) 11901 } 11902 11903 case "unhealthyThreshold": 11904 if value != nil { 11905 jtv, ok := value.(json.Number) 11906 if !ok { 11907 return fmt.Errorf("expected VirtualGatewayHealthCheckThreshold to be json.Number, got %T instead", value) 11908 } 11909 i64, err := jtv.Int64() 11910 if err != nil { 11911 return err 11912 } 11913 sv.UnhealthyThreshold = int32(i64) 11914 } 11915 11916 default: 11917 _, _ = key, value 11918 11919 } 11920 } 11921 *v = sv 11922 return nil 11923} 11924 11925func awsRestjson1_deserializeDocumentVirtualGatewayHttp2ConnectionPool(v **types.VirtualGatewayHttp2ConnectionPool, value interface{}) error { 11926 if v == nil { 11927 return fmt.Errorf("unexpected nil of type %T", v) 11928 } 11929 if value == nil { 11930 return nil 11931 } 11932 11933 shape, ok := value.(map[string]interface{}) 11934 if !ok { 11935 return fmt.Errorf("unexpected JSON type %v", value) 11936 } 11937 11938 var sv *types.VirtualGatewayHttp2ConnectionPool 11939 if *v == nil { 11940 sv = &types.VirtualGatewayHttp2ConnectionPool{} 11941 } else { 11942 sv = *v 11943 } 11944 11945 for key, value := range shape { 11946 switch key { 11947 case "maxRequests": 11948 if value != nil { 11949 jtv, ok := value.(json.Number) 11950 if !ok { 11951 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 11952 } 11953 i64, err := jtv.Int64() 11954 if err != nil { 11955 return err 11956 } 11957 sv.MaxRequests = int32(i64) 11958 } 11959 11960 default: 11961 _, _ = key, value 11962 11963 } 11964 } 11965 *v = sv 11966 return nil 11967} 11968 11969func awsRestjson1_deserializeDocumentVirtualGatewayHttpConnectionPool(v **types.VirtualGatewayHttpConnectionPool, value interface{}) error { 11970 if v == nil { 11971 return fmt.Errorf("unexpected nil of type %T", v) 11972 } 11973 if value == nil { 11974 return nil 11975 } 11976 11977 shape, ok := value.(map[string]interface{}) 11978 if !ok { 11979 return fmt.Errorf("unexpected JSON type %v", value) 11980 } 11981 11982 var sv *types.VirtualGatewayHttpConnectionPool 11983 if *v == nil { 11984 sv = &types.VirtualGatewayHttpConnectionPool{} 11985 } else { 11986 sv = *v 11987 } 11988 11989 for key, value := range shape { 11990 switch key { 11991 case "maxConnections": 11992 if value != nil { 11993 jtv, ok := value.(json.Number) 11994 if !ok { 11995 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 11996 } 11997 i64, err := jtv.Int64() 11998 if err != nil { 11999 return err 12000 } 12001 sv.MaxConnections = int32(i64) 12002 } 12003 12004 case "maxPendingRequests": 12005 if value != nil { 12006 jtv, ok := value.(json.Number) 12007 if !ok { 12008 return fmt.Errorf("expected MaxPendingRequests to be json.Number, got %T instead", value) 12009 } 12010 i64, err := jtv.Int64() 12011 if err != nil { 12012 return err 12013 } 12014 sv.MaxPendingRequests = int32(i64) 12015 } 12016 12017 default: 12018 _, _ = key, value 12019 12020 } 12021 } 12022 *v = sv 12023 return nil 12024} 12025 12026func awsRestjson1_deserializeDocumentVirtualGatewayList(v *[]types.VirtualGatewayRef, value interface{}) error { 12027 if v == nil { 12028 return fmt.Errorf("unexpected nil of type %T", v) 12029 } 12030 if value == nil { 12031 return nil 12032 } 12033 12034 shape, ok := value.([]interface{}) 12035 if !ok { 12036 return fmt.Errorf("unexpected JSON type %v", value) 12037 } 12038 12039 var cv []types.VirtualGatewayRef 12040 if *v == nil { 12041 cv = []types.VirtualGatewayRef{} 12042 } else { 12043 cv = *v 12044 } 12045 12046 for _, value := range shape { 12047 var col types.VirtualGatewayRef 12048 destAddr := &col 12049 if err := awsRestjson1_deserializeDocumentVirtualGatewayRef(&destAddr, value); err != nil { 12050 return err 12051 } 12052 col = *destAddr 12053 cv = append(cv, col) 12054 12055 } 12056 *v = cv 12057 return nil 12058} 12059 12060func awsRestjson1_deserializeDocumentVirtualGatewayListener(v **types.VirtualGatewayListener, value interface{}) error { 12061 if v == nil { 12062 return fmt.Errorf("unexpected nil of type %T", v) 12063 } 12064 if value == nil { 12065 return nil 12066 } 12067 12068 shape, ok := value.(map[string]interface{}) 12069 if !ok { 12070 return fmt.Errorf("unexpected JSON type %v", value) 12071 } 12072 12073 var sv *types.VirtualGatewayListener 12074 if *v == nil { 12075 sv = &types.VirtualGatewayListener{} 12076 } else { 12077 sv = *v 12078 } 12079 12080 for key, value := range shape { 12081 switch key { 12082 case "connectionPool": 12083 if err := awsRestjson1_deserializeDocumentVirtualGatewayConnectionPool(&sv.ConnectionPool, value); err != nil { 12084 return err 12085 } 12086 12087 case "healthCheck": 12088 if err := awsRestjson1_deserializeDocumentVirtualGatewayHealthCheckPolicy(&sv.HealthCheck, value); err != nil { 12089 return err 12090 } 12091 12092 case "portMapping": 12093 if err := awsRestjson1_deserializeDocumentVirtualGatewayPortMapping(&sv.PortMapping, value); err != nil { 12094 return err 12095 } 12096 12097 case "tls": 12098 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTls(&sv.Tls, value); err != nil { 12099 return err 12100 } 12101 12102 default: 12103 _, _ = key, value 12104 12105 } 12106 } 12107 *v = sv 12108 return nil 12109} 12110 12111func awsRestjson1_deserializeDocumentVirtualGatewayListeners(v *[]types.VirtualGatewayListener, value interface{}) error { 12112 if v == nil { 12113 return fmt.Errorf("unexpected nil of type %T", v) 12114 } 12115 if value == nil { 12116 return nil 12117 } 12118 12119 shape, ok := value.([]interface{}) 12120 if !ok { 12121 return fmt.Errorf("unexpected JSON type %v", value) 12122 } 12123 12124 var cv []types.VirtualGatewayListener 12125 if *v == nil { 12126 cv = []types.VirtualGatewayListener{} 12127 } else { 12128 cv = *v 12129 } 12130 12131 for _, value := range shape { 12132 var col types.VirtualGatewayListener 12133 destAddr := &col 12134 if err := awsRestjson1_deserializeDocumentVirtualGatewayListener(&destAddr, value); err != nil { 12135 return err 12136 } 12137 col = *destAddr 12138 cv = append(cv, col) 12139 12140 } 12141 *v = cv 12142 return nil 12143} 12144 12145func awsRestjson1_deserializeDocumentVirtualGatewayListenerTls(v **types.VirtualGatewayListenerTls, value interface{}) error { 12146 if v == nil { 12147 return fmt.Errorf("unexpected nil of type %T", v) 12148 } 12149 if value == nil { 12150 return nil 12151 } 12152 12153 shape, ok := value.(map[string]interface{}) 12154 if !ok { 12155 return fmt.Errorf("unexpected JSON type %v", value) 12156 } 12157 12158 var sv *types.VirtualGatewayListenerTls 12159 if *v == nil { 12160 sv = &types.VirtualGatewayListenerTls{} 12161 } else { 12162 sv = *v 12163 } 12164 12165 for key, value := range shape { 12166 switch key { 12167 case "certificate": 12168 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsCertificate(&sv.Certificate, value); err != nil { 12169 return err 12170 } 12171 12172 case "mode": 12173 if value != nil { 12174 jtv, ok := value.(string) 12175 if !ok { 12176 return fmt.Errorf("expected VirtualGatewayListenerTlsMode to be of type string, got %T instead", value) 12177 } 12178 sv.Mode = types.VirtualGatewayListenerTlsMode(jtv) 12179 } 12180 12181 case "validation": 12182 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContext(&sv.Validation, value); err != nil { 12183 return err 12184 } 12185 12186 default: 12187 _, _ = key, value 12188 12189 } 12190 } 12191 *v = sv 12192 return nil 12193} 12194 12195func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsAcmCertificate(v **types.VirtualGatewayListenerTlsAcmCertificate, value interface{}) error { 12196 if v == nil { 12197 return fmt.Errorf("unexpected nil of type %T", v) 12198 } 12199 if value == nil { 12200 return nil 12201 } 12202 12203 shape, ok := value.(map[string]interface{}) 12204 if !ok { 12205 return fmt.Errorf("unexpected JSON type %v", value) 12206 } 12207 12208 var sv *types.VirtualGatewayListenerTlsAcmCertificate 12209 if *v == nil { 12210 sv = &types.VirtualGatewayListenerTlsAcmCertificate{} 12211 } else { 12212 sv = *v 12213 } 12214 12215 for key, value := range shape { 12216 switch key { 12217 case "certificateArn": 12218 if value != nil { 12219 jtv, ok := value.(string) 12220 if !ok { 12221 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 12222 } 12223 sv.CertificateArn = ptr.String(jtv) 12224 } 12225 12226 default: 12227 _, _ = key, value 12228 12229 } 12230 } 12231 *v = sv 12232 return nil 12233} 12234 12235func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsCertificate(v *types.VirtualGatewayListenerTlsCertificate, value interface{}) error { 12236 if v == nil { 12237 return fmt.Errorf("unexpected nil of type %T", v) 12238 } 12239 if value == nil { 12240 return nil 12241 } 12242 12243 shape, ok := value.(map[string]interface{}) 12244 if !ok { 12245 return fmt.Errorf("unexpected JSON type %v", value) 12246 } 12247 12248 var uv types.VirtualGatewayListenerTlsCertificate 12249loop: 12250 for key, value := range shape { 12251 if value == nil { 12252 continue 12253 } 12254 switch key { 12255 case "acm": 12256 var mv types.VirtualGatewayListenerTlsAcmCertificate 12257 destAddr := &mv 12258 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsAcmCertificate(&destAddr, value); err != nil { 12259 return err 12260 } 12261 mv = *destAddr 12262 uv = &types.VirtualGatewayListenerTlsCertificateMemberAcm{Value: mv} 12263 break loop 12264 12265 case "file": 12266 var mv types.VirtualGatewayListenerTlsFileCertificate 12267 destAddr := &mv 12268 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(&destAddr, value); err != nil { 12269 return err 12270 } 12271 mv = *destAddr 12272 uv = &types.VirtualGatewayListenerTlsCertificateMemberFile{Value: mv} 12273 break loop 12274 12275 case "sds": 12276 var mv types.VirtualGatewayListenerTlsSdsCertificate 12277 destAddr := &mv 12278 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(&destAddr, value); err != nil { 12279 return err 12280 } 12281 mv = *destAddr 12282 uv = &types.VirtualGatewayListenerTlsCertificateMemberSds{Value: mv} 12283 break loop 12284 12285 default: 12286 uv = &types.UnknownUnionMember{Tag: key} 12287 break loop 12288 12289 } 12290 } 12291 *v = uv 12292 return nil 12293} 12294 12295func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(v **types.VirtualGatewayListenerTlsFileCertificate, value interface{}) error { 12296 if v == nil { 12297 return fmt.Errorf("unexpected nil of type %T", v) 12298 } 12299 if value == nil { 12300 return nil 12301 } 12302 12303 shape, ok := value.(map[string]interface{}) 12304 if !ok { 12305 return fmt.Errorf("unexpected JSON type %v", value) 12306 } 12307 12308 var sv *types.VirtualGatewayListenerTlsFileCertificate 12309 if *v == nil { 12310 sv = &types.VirtualGatewayListenerTlsFileCertificate{} 12311 } else { 12312 sv = *v 12313 } 12314 12315 for key, value := range shape { 12316 switch key { 12317 case "certificateChain": 12318 if value != nil { 12319 jtv, ok := value.(string) 12320 if !ok { 12321 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 12322 } 12323 sv.CertificateChain = ptr.String(jtv) 12324 } 12325 12326 case "privateKey": 12327 if value != nil { 12328 jtv, ok := value.(string) 12329 if !ok { 12330 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 12331 } 12332 sv.PrivateKey = ptr.String(jtv) 12333 } 12334 12335 default: 12336 _, _ = key, value 12337 12338 } 12339 } 12340 *v = sv 12341 return nil 12342} 12343 12344func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(v **types.VirtualGatewayListenerTlsSdsCertificate, value interface{}) error { 12345 if v == nil { 12346 return fmt.Errorf("unexpected nil of type %T", v) 12347 } 12348 if value == nil { 12349 return nil 12350 } 12351 12352 shape, ok := value.(map[string]interface{}) 12353 if !ok { 12354 return fmt.Errorf("unexpected JSON type %v", value) 12355 } 12356 12357 var sv *types.VirtualGatewayListenerTlsSdsCertificate 12358 if *v == nil { 12359 sv = &types.VirtualGatewayListenerTlsSdsCertificate{} 12360 } else { 12361 sv = *v 12362 } 12363 12364 for key, value := range shape { 12365 switch key { 12366 case "secretName": 12367 if value != nil { 12368 jtv, ok := value.(string) 12369 if !ok { 12370 return fmt.Errorf("expected VirtualGatewaySdsSecretName to be of type string, got %T instead", value) 12371 } 12372 sv.SecretName = ptr.String(jtv) 12373 } 12374 12375 default: 12376 _, _ = key, value 12377 12378 } 12379 } 12380 *v = sv 12381 return nil 12382} 12383 12384func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContext(v **types.VirtualGatewayListenerTlsValidationContext, value interface{}) error { 12385 if v == nil { 12386 return fmt.Errorf("unexpected nil of type %T", v) 12387 } 12388 if value == nil { 12389 return nil 12390 } 12391 12392 shape, ok := value.(map[string]interface{}) 12393 if !ok { 12394 return fmt.Errorf("unexpected JSON type %v", value) 12395 } 12396 12397 var sv *types.VirtualGatewayListenerTlsValidationContext 12398 if *v == nil { 12399 sv = &types.VirtualGatewayListenerTlsValidationContext{} 12400 } else { 12401 sv = *v 12402 } 12403 12404 for key, value := range shape { 12405 switch key { 12406 case "subjectAlternativeNames": 12407 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 12408 return err 12409 } 12410 12411 case "trust": 12412 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContextTrust(&sv.Trust, value); err != nil { 12413 return err 12414 } 12415 12416 default: 12417 _, _ = key, value 12418 12419 } 12420 } 12421 *v = sv 12422 return nil 12423} 12424 12425func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContextTrust(v *types.VirtualGatewayListenerTlsValidationContextTrust, value interface{}) error { 12426 if v == nil { 12427 return fmt.Errorf("unexpected nil of type %T", v) 12428 } 12429 if value == nil { 12430 return nil 12431 } 12432 12433 shape, ok := value.(map[string]interface{}) 12434 if !ok { 12435 return fmt.Errorf("unexpected JSON type %v", value) 12436 } 12437 12438 var uv types.VirtualGatewayListenerTlsValidationContextTrust 12439loop: 12440 for key, value := range shape { 12441 if value == nil { 12442 continue 12443 } 12444 switch key { 12445 case "file": 12446 var mv types.VirtualGatewayTlsValidationContextFileTrust 12447 destAddr := &mv 12448 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(&destAddr, value); err != nil { 12449 return err 12450 } 12451 mv = *destAddr 12452 uv = &types.VirtualGatewayListenerTlsValidationContextTrustMemberFile{Value: mv} 12453 break loop 12454 12455 case "sds": 12456 var mv types.VirtualGatewayTlsValidationContextSdsTrust 12457 destAddr := &mv 12458 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(&destAddr, value); err != nil { 12459 return err 12460 } 12461 mv = *destAddr 12462 uv = &types.VirtualGatewayListenerTlsValidationContextTrustMemberSds{Value: mv} 12463 break loop 12464 12465 default: 12466 uv = &types.UnknownUnionMember{Tag: key} 12467 break loop 12468 12469 } 12470 } 12471 *v = uv 12472 return nil 12473} 12474 12475func awsRestjson1_deserializeDocumentVirtualGatewayLogging(v **types.VirtualGatewayLogging, value interface{}) error { 12476 if v == nil { 12477 return fmt.Errorf("unexpected nil of type %T", v) 12478 } 12479 if value == nil { 12480 return nil 12481 } 12482 12483 shape, ok := value.(map[string]interface{}) 12484 if !ok { 12485 return fmt.Errorf("unexpected JSON type %v", value) 12486 } 12487 12488 var sv *types.VirtualGatewayLogging 12489 if *v == nil { 12490 sv = &types.VirtualGatewayLogging{} 12491 } else { 12492 sv = *v 12493 } 12494 12495 for key, value := range shape { 12496 switch key { 12497 case "accessLog": 12498 if err := awsRestjson1_deserializeDocumentVirtualGatewayAccessLog(&sv.AccessLog, value); err != nil { 12499 return err 12500 } 12501 12502 default: 12503 _, _ = key, value 12504 12505 } 12506 } 12507 *v = sv 12508 return nil 12509} 12510 12511func awsRestjson1_deserializeDocumentVirtualGatewayPortMapping(v **types.VirtualGatewayPortMapping, value interface{}) error { 12512 if v == nil { 12513 return fmt.Errorf("unexpected nil of type %T", v) 12514 } 12515 if value == nil { 12516 return nil 12517 } 12518 12519 shape, ok := value.(map[string]interface{}) 12520 if !ok { 12521 return fmt.Errorf("unexpected JSON type %v", value) 12522 } 12523 12524 var sv *types.VirtualGatewayPortMapping 12525 if *v == nil { 12526 sv = &types.VirtualGatewayPortMapping{} 12527 } else { 12528 sv = *v 12529 } 12530 12531 for key, value := range shape { 12532 switch key { 12533 case "port": 12534 if value != nil { 12535 jtv, ok := value.(json.Number) 12536 if !ok { 12537 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 12538 } 12539 i64, err := jtv.Int64() 12540 if err != nil { 12541 return err 12542 } 12543 sv.Port = int32(i64) 12544 } 12545 12546 case "protocol": 12547 if value != nil { 12548 jtv, ok := value.(string) 12549 if !ok { 12550 return fmt.Errorf("expected VirtualGatewayPortProtocol to be of type string, got %T instead", value) 12551 } 12552 sv.Protocol = types.VirtualGatewayPortProtocol(jtv) 12553 } 12554 12555 default: 12556 _, _ = key, value 12557 12558 } 12559 } 12560 *v = sv 12561 return nil 12562} 12563 12564func awsRestjson1_deserializeDocumentVirtualGatewayRef(v **types.VirtualGatewayRef, value interface{}) error { 12565 if v == nil { 12566 return fmt.Errorf("unexpected nil of type %T", v) 12567 } 12568 if value == nil { 12569 return nil 12570 } 12571 12572 shape, ok := value.(map[string]interface{}) 12573 if !ok { 12574 return fmt.Errorf("unexpected JSON type %v", value) 12575 } 12576 12577 var sv *types.VirtualGatewayRef 12578 if *v == nil { 12579 sv = &types.VirtualGatewayRef{} 12580 } else { 12581 sv = *v 12582 } 12583 12584 for key, value := range shape { 12585 switch key { 12586 case "arn": 12587 if value != nil { 12588 jtv, ok := value.(string) 12589 if !ok { 12590 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 12591 } 12592 sv.Arn = ptr.String(jtv) 12593 } 12594 12595 case "createdAt": 12596 if value != nil { 12597 jtv, ok := value.(json.Number) 12598 if !ok { 12599 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 12600 } 12601 f64, err := jtv.Float64() 12602 if err != nil { 12603 return err 12604 } 12605 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12606 } 12607 12608 case "lastUpdatedAt": 12609 if value != nil { 12610 jtv, ok := value.(json.Number) 12611 if !ok { 12612 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 12613 } 12614 f64, err := jtv.Float64() 12615 if err != nil { 12616 return err 12617 } 12618 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12619 } 12620 12621 case "meshName": 12622 if value != nil { 12623 jtv, ok := value.(string) 12624 if !ok { 12625 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 12626 } 12627 sv.MeshName = ptr.String(jtv) 12628 } 12629 12630 case "meshOwner": 12631 if value != nil { 12632 jtv, ok := value.(string) 12633 if !ok { 12634 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 12635 } 12636 sv.MeshOwner = ptr.String(jtv) 12637 } 12638 12639 case "resourceOwner": 12640 if value != nil { 12641 jtv, ok := value.(string) 12642 if !ok { 12643 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 12644 } 12645 sv.ResourceOwner = ptr.String(jtv) 12646 } 12647 12648 case "version": 12649 if value != nil { 12650 jtv, ok := value.(json.Number) 12651 if !ok { 12652 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12653 } 12654 i64, err := jtv.Int64() 12655 if err != nil { 12656 return err 12657 } 12658 sv.Version = ptr.Int64(i64) 12659 } 12660 12661 case "virtualGatewayName": 12662 if value != nil { 12663 jtv, ok := value.(string) 12664 if !ok { 12665 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 12666 } 12667 sv.VirtualGatewayName = ptr.String(jtv) 12668 } 12669 12670 default: 12671 _, _ = key, value 12672 12673 } 12674 } 12675 *v = sv 12676 return nil 12677} 12678 12679func awsRestjson1_deserializeDocumentVirtualGatewaySpec(v **types.VirtualGatewaySpec, value interface{}) error { 12680 if v == nil { 12681 return fmt.Errorf("unexpected nil of type %T", v) 12682 } 12683 if value == nil { 12684 return nil 12685 } 12686 12687 shape, ok := value.(map[string]interface{}) 12688 if !ok { 12689 return fmt.Errorf("unexpected JSON type %v", value) 12690 } 12691 12692 var sv *types.VirtualGatewaySpec 12693 if *v == nil { 12694 sv = &types.VirtualGatewaySpec{} 12695 } else { 12696 sv = *v 12697 } 12698 12699 for key, value := range shape { 12700 switch key { 12701 case "backendDefaults": 12702 if err := awsRestjson1_deserializeDocumentVirtualGatewayBackendDefaults(&sv.BackendDefaults, value); err != nil { 12703 return err 12704 } 12705 12706 case "listeners": 12707 if err := awsRestjson1_deserializeDocumentVirtualGatewayListeners(&sv.Listeners, value); err != nil { 12708 return err 12709 } 12710 12711 case "logging": 12712 if err := awsRestjson1_deserializeDocumentVirtualGatewayLogging(&sv.Logging, value); err != nil { 12713 return err 12714 } 12715 12716 default: 12717 _, _ = key, value 12718 12719 } 12720 } 12721 *v = sv 12722 return nil 12723} 12724 12725func awsRestjson1_deserializeDocumentVirtualGatewayStatus(v **types.VirtualGatewayStatus, value interface{}) error { 12726 if v == nil { 12727 return fmt.Errorf("unexpected nil of type %T", v) 12728 } 12729 if value == nil { 12730 return nil 12731 } 12732 12733 shape, ok := value.(map[string]interface{}) 12734 if !ok { 12735 return fmt.Errorf("unexpected JSON type %v", value) 12736 } 12737 12738 var sv *types.VirtualGatewayStatus 12739 if *v == nil { 12740 sv = &types.VirtualGatewayStatus{} 12741 } else { 12742 sv = *v 12743 } 12744 12745 for key, value := range shape { 12746 switch key { 12747 case "status": 12748 if value != nil { 12749 jtv, ok := value.(string) 12750 if !ok { 12751 return fmt.Errorf("expected VirtualGatewayStatusCode to be of type string, got %T instead", value) 12752 } 12753 sv.Status = types.VirtualGatewayStatusCode(jtv) 12754 } 12755 12756 default: 12757 _, _ = key, value 12758 12759 } 12760 } 12761 *v = sv 12762 return nil 12763} 12764 12765func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContext(v **types.VirtualGatewayTlsValidationContext, value interface{}) error { 12766 if v == nil { 12767 return fmt.Errorf("unexpected nil of type %T", v) 12768 } 12769 if value == nil { 12770 return nil 12771 } 12772 12773 shape, ok := value.(map[string]interface{}) 12774 if !ok { 12775 return fmt.Errorf("unexpected JSON type %v", value) 12776 } 12777 12778 var sv *types.VirtualGatewayTlsValidationContext 12779 if *v == nil { 12780 sv = &types.VirtualGatewayTlsValidationContext{} 12781 } else { 12782 sv = *v 12783 } 12784 12785 for key, value := range shape { 12786 switch key { 12787 case "subjectAlternativeNames": 12788 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 12789 return err 12790 } 12791 12792 case "trust": 12793 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextTrust(&sv.Trust, value); err != nil { 12794 return err 12795 } 12796 12797 default: 12798 _, _ = key, value 12799 12800 } 12801 } 12802 *v = sv 12803 return nil 12804} 12805 12806func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextAcmTrust(v **types.VirtualGatewayTlsValidationContextAcmTrust, value interface{}) error { 12807 if v == nil { 12808 return fmt.Errorf("unexpected nil of type %T", v) 12809 } 12810 if value == nil { 12811 return nil 12812 } 12813 12814 shape, ok := value.(map[string]interface{}) 12815 if !ok { 12816 return fmt.Errorf("unexpected JSON type %v", value) 12817 } 12818 12819 var sv *types.VirtualGatewayTlsValidationContextAcmTrust 12820 if *v == nil { 12821 sv = &types.VirtualGatewayTlsValidationContextAcmTrust{} 12822 } else { 12823 sv = *v 12824 } 12825 12826 for key, value := range shape { 12827 switch key { 12828 case "certificateAuthorityArns": 12829 if err := awsRestjson1_deserializeDocumentVirtualGatewayCertificateAuthorityArns(&sv.CertificateAuthorityArns, value); err != nil { 12830 return err 12831 } 12832 12833 default: 12834 _, _ = key, value 12835 12836 } 12837 } 12838 *v = sv 12839 return nil 12840} 12841 12842func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(v **types.VirtualGatewayTlsValidationContextFileTrust, value interface{}) error { 12843 if v == nil { 12844 return fmt.Errorf("unexpected nil of type %T", v) 12845 } 12846 if value == nil { 12847 return nil 12848 } 12849 12850 shape, ok := value.(map[string]interface{}) 12851 if !ok { 12852 return fmt.Errorf("unexpected JSON type %v", value) 12853 } 12854 12855 var sv *types.VirtualGatewayTlsValidationContextFileTrust 12856 if *v == nil { 12857 sv = &types.VirtualGatewayTlsValidationContextFileTrust{} 12858 } else { 12859 sv = *v 12860 } 12861 12862 for key, value := range shape { 12863 switch key { 12864 case "certificateChain": 12865 if value != nil { 12866 jtv, ok := value.(string) 12867 if !ok { 12868 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 12869 } 12870 sv.CertificateChain = ptr.String(jtv) 12871 } 12872 12873 default: 12874 _, _ = key, value 12875 12876 } 12877 } 12878 *v = sv 12879 return nil 12880} 12881 12882func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(v **types.VirtualGatewayTlsValidationContextSdsTrust, value interface{}) error { 12883 if v == nil { 12884 return fmt.Errorf("unexpected nil of type %T", v) 12885 } 12886 if value == nil { 12887 return nil 12888 } 12889 12890 shape, ok := value.(map[string]interface{}) 12891 if !ok { 12892 return fmt.Errorf("unexpected JSON type %v", value) 12893 } 12894 12895 var sv *types.VirtualGatewayTlsValidationContextSdsTrust 12896 if *v == nil { 12897 sv = &types.VirtualGatewayTlsValidationContextSdsTrust{} 12898 } else { 12899 sv = *v 12900 } 12901 12902 for key, value := range shape { 12903 switch key { 12904 case "secretName": 12905 if value != nil { 12906 jtv, ok := value.(string) 12907 if !ok { 12908 return fmt.Errorf("expected VirtualGatewaySdsSecretName to be of type string, got %T instead", value) 12909 } 12910 sv.SecretName = ptr.String(jtv) 12911 } 12912 12913 default: 12914 _, _ = key, value 12915 12916 } 12917 } 12918 *v = sv 12919 return nil 12920} 12921 12922func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextTrust(v *types.VirtualGatewayTlsValidationContextTrust, value interface{}) error { 12923 if v == nil { 12924 return fmt.Errorf("unexpected nil of type %T", v) 12925 } 12926 if value == nil { 12927 return nil 12928 } 12929 12930 shape, ok := value.(map[string]interface{}) 12931 if !ok { 12932 return fmt.Errorf("unexpected JSON type %v", value) 12933 } 12934 12935 var uv types.VirtualGatewayTlsValidationContextTrust 12936loop: 12937 for key, value := range shape { 12938 if value == nil { 12939 continue 12940 } 12941 switch key { 12942 case "acm": 12943 var mv types.VirtualGatewayTlsValidationContextAcmTrust 12944 destAddr := &mv 12945 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextAcmTrust(&destAddr, value); err != nil { 12946 return err 12947 } 12948 mv = *destAddr 12949 uv = &types.VirtualGatewayTlsValidationContextTrustMemberAcm{Value: mv} 12950 break loop 12951 12952 case "file": 12953 var mv types.VirtualGatewayTlsValidationContextFileTrust 12954 destAddr := &mv 12955 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(&destAddr, value); err != nil { 12956 return err 12957 } 12958 mv = *destAddr 12959 uv = &types.VirtualGatewayTlsValidationContextTrustMemberFile{Value: mv} 12960 break loop 12961 12962 case "sds": 12963 var mv types.VirtualGatewayTlsValidationContextSdsTrust 12964 destAddr := &mv 12965 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(&destAddr, value); err != nil { 12966 return err 12967 } 12968 mv = *destAddr 12969 uv = &types.VirtualGatewayTlsValidationContextTrustMemberSds{Value: mv} 12970 break loop 12971 12972 default: 12973 uv = &types.UnknownUnionMember{Tag: key} 12974 break loop 12975 12976 } 12977 } 12978 *v = uv 12979 return nil 12980} 12981 12982func awsRestjson1_deserializeDocumentVirtualNodeConnectionPool(v *types.VirtualNodeConnectionPool, value interface{}) error { 12983 if v == nil { 12984 return fmt.Errorf("unexpected nil of type %T", v) 12985 } 12986 if value == nil { 12987 return nil 12988 } 12989 12990 shape, ok := value.(map[string]interface{}) 12991 if !ok { 12992 return fmt.Errorf("unexpected JSON type %v", value) 12993 } 12994 12995 var uv types.VirtualNodeConnectionPool 12996loop: 12997 for key, value := range shape { 12998 if value == nil { 12999 continue 13000 } 13001 switch key { 13002 case "grpc": 13003 var mv types.VirtualNodeGrpcConnectionPool 13004 destAddr := &mv 13005 if err := awsRestjson1_deserializeDocumentVirtualNodeGrpcConnectionPool(&destAddr, value); err != nil { 13006 return err 13007 } 13008 mv = *destAddr 13009 uv = &types.VirtualNodeConnectionPoolMemberGrpc{Value: mv} 13010 break loop 13011 13012 case "http": 13013 var mv types.VirtualNodeHttpConnectionPool 13014 destAddr := &mv 13015 if err := awsRestjson1_deserializeDocumentVirtualNodeHttpConnectionPool(&destAddr, value); err != nil { 13016 return err 13017 } 13018 mv = *destAddr 13019 uv = &types.VirtualNodeConnectionPoolMemberHttp{Value: mv} 13020 break loop 13021 13022 case "http2": 13023 var mv types.VirtualNodeHttp2ConnectionPool 13024 destAddr := &mv 13025 if err := awsRestjson1_deserializeDocumentVirtualNodeHttp2ConnectionPool(&destAddr, value); err != nil { 13026 return err 13027 } 13028 mv = *destAddr 13029 uv = &types.VirtualNodeConnectionPoolMemberHttp2{Value: mv} 13030 break loop 13031 13032 case "tcp": 13033 var mv types.VirtualNodeTcpConnectionPool 13034 destAddr := &mv 13035 if err := awsRestjson1_deserializeDocumentVirtualNodeTcpConnectionPool(&destAddr, value); err != nil { 13036 return err 13037 } 13038 mv = *destAddr 13039 uv = &types.VirtualNodeConnectionPoolMemberTcp{Value: mv} 13040 break loop 13041 13042 default: 13043 uv = &types.UnknownUnionMember{Tag: key} 13044 break loop 13045 13046 } 13047 } 13048 *v = uv 13049 return nil 13050} 13051 13052func awsRestjson1_deserializeDocumentVirtualNodeData(v **types.VirtualNodeData, value interface{}) error { 13053 if v == nil { 13054 return fmt.Errorf("unexpected nil of type %T", v) 13055 } 13056 if value == nil { 13057 return nil 13058 } 13059 13060 shape, ok := value.(map[string]interface{}) 13061 if !ok { 13062 return fmt.Errorf("unexpected JSON type %v", value) 13063 } 13064 13065 var sv *types.VirtualNodeData 13066 if *v == nil { 13067 sv = &types.VirtualNodeData{} 13068 } else { 13069 sv = *v 13070 } 13071 13072 for key, value := range shape { 13073 switch key { 13074 case "meshName": 13075 if value != nil { 13076 jtv, ok := value.(string) 13077 if !ok { 13078 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13079 } 13080 sv.MeshName = ptr.String(jtv) 13081 } 13082 13083 case "metadata": 13084 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 13085 return err 13086 } 13087 13088 case "spec": 13089 if err := awsRestjson1_deserializeDocumentVirtualNodeSpec(&sv.Spec, value); err != nil { 13090 return err 13091 } 13092 13093 case "status": 13094 if err := awsRestjson1_deserializeDocumentVirtualNodeStatus(&sv.Status, value); err != nil { 13095 return err 13096 } 13097 13098 case "virtualNodeName": 13099 if value != nil { 13100 jtv, ok := value.(string) 13101 if !ok { 13102 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13103 } 13104 sv.VirtualNodeName = ptr.String(jtv) 13105 } 13106 13107 default: 13108 _, _ = key, value 13109 13110 } 13111 } 13112 *v = sv 13113 return nil 13114} 13115 13116func awsRestjson1_deserializeDocumentVirtualNodeGrpcConnectionPool(v **types.VirtualNodeGrpcConnectionPool, value interface{}) error { 13117 if v == nil { 13118 return fmt.Errorf("unexpected nil of type %T", v) 13119 } 13120 if value == nil { 13121 return nil 13122 } 13123 13124 shape, ok := value.(map[string]interface{}) 13125 if !ok { 13126 return fmt.Errorf("unexpected JSON type %v", value) 13127 } 13128 13129 var sv *types.VirtualNodeGrpcConnectionPool 13130 if *v == nil { 13131 sv = &types.VirtualNodeGrpcConnectionPool{} 13132 } else { 13133 sv = *v 13134 } 13135 13136 for key, value := range shape { 13137 switch key { 13138 case "maxRequests": 13139 if value != nil { 13140 jtv, ok := value.(json.Number) 13141 if !ok { 13142 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 13143 } 13144 i64, err := jtv.Int64() 13145 if err != nil { 13146 return err 13147 } 13148 sv.MaxRequests = int32(i64) 13149 } 13150 13151 default: 13152 _, _ = key, value 13153 13154 } 13155 } 13156 *v = sv 13157 return nil 13158} 13159 13160func awsRestjson1_deserializeDocumentVirtualNodeHttp2ConnectionPool(v **types.VirtualNodeHttp2ConnectionPool, value interface{}) error { 13161 if v == nil { 13162 return fmt.Errorf("unexpected nil of type %T", v) 13163 } 13164 if value == nil { 13165 return nil 13166 } 13167 13168 shape, ok := value.(map[string]interface{}) 13169 if !ok { 13170 return fmt.Errorf("unexpected JSON type %v", value) 13171 } 13172 13173 var sv *types.VirtualNodeHttp2ConnectionPool 13174 if *v == nil { 13175 sv = &types.VirtualNodeHttp2ConnectionPool{} 13176 } else { 13177 sv = *v 13178 } 13179 13180 for key, value := range shape { 13181 switch key { 13182 case "maxRequests": 13183 if value != nil { 13184 jtv, ok := value.(json.Number) 13185 if !ok { 13186 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 13187 } 13188 i64, err := jtv.Int64() 13189 if err != nil { 13190 return err 13191 } 13192 sv.MaxRequests = int32(i64) 13193 } 13194 13195 default: 13196 _, _ = key, value 13197 13198 } 13199 } 13200 *v = sv 13201 return nil 13202} 13203 13204func awsRestjson1_deserializeDocumentVirtualNodeHttpConnectionPool(v **types.VirtualNodeHttpConnectionPool, value interface{}) error { 13205 if v == nil { 13206 return fmt.Errorf("unexpected nil of type %T", v) 13207 } 13208 if value == nil { 13209 return nil 13210 } 13211 13212 shape, ok := value.(map[string]interface{}) 13213 if !ok { 13214 return fmt.Errorf("unexpected JSON type %v", value) 13215 } 13216 13217 var sv *types.VirtualNodeHttpConnectionPool 13218 if *v == nil { 13219 sv = &types.VirtualNodeHttpConnectionPool{} 13220 } else { 13221 sv = *v 13222 } 13223 13224 for key, value := range shape { 13225 switch key { 13226 case "maxConnections": 13227 if value != nil { 13228 jtv, ok := value.(json.Number) 13229 if !ok { 13230 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 13231 } 13232 i64, err := jtv.Int64() 13233 if err != nil { 13234 return err 13235 } 13236 sv.MaxConnections = int32(i64) 13237 } 13238 13239 case "maxPendingRequests": 13240 if value != nil { 13241 jtv, ok := value.(json.Number) 13242 if !ok { 13243 return fmt.Errorf("expected MaxPendingRequests to be json.Number, got %T instead", value) 13244 } 13245 i64, err := jtv.Int64() 13246 if err != nil { 13247 return err 13248 } 13249 sv.MaxPendingRequests = int32(i64) 13250 } 13251 13252 default: 13253 _, _ = key, value 13254 13255 } 13256 } 13257 *v = sv 13258 return nil 13259} 13260 13261func awsRestjson1_deserializeDocumentVirtualNodeList(v *[]types.VirtualNodeRef, value interface{}) error { 13262 if v == nil { 13263 return fmt.Errorf("unexpected nil of type %T", v) 13264 } 13265 if value == nil { 13266 return nil 13267 } 13268 13269 shape, ok := value.([]interface{}) 13270 if !ok { 13271 return fmt.Errorf("unexpected JSON type %v", value) 13272 } 13273 13274 var cv []types.VirtualNodeRef 13275 if *v == nil { 13276 cv = []types.VirtualNodeRef{} 13277 } else { 13278 cv = *v 13279 } 13280 13281 for _, value := range shape { 13282 var col types.VirtualNodeRef 13283 destAddr := &col 13284 if err := awsRestjson1_deserializeDocumentVirtualNodeRef(&destAddr, value); err != nil { 13285 return err 13286 } 13287 col = *destAddr 13288 cv = append(cv, col) 13289 13290 } 13291 *v = cv 13292 return nil 13293} 13294 13295func awsRestjson1_deserializeDocumentVirtualNodeRef(v **types.VirtualNodeRef, value interface{}) error { 13296 if v == nil { 13297 return fmt.Errorf("unexpected nil of type %T", v) 13298 } 13299 if value == nil { 13300 return nil 13301 } 13302 13303 shape, ok := value.(map[string]interface{}) 13304 if !ok { 13305 return fmt.Errorf("unexpected JSON type %v", value) 13306 } 13307 13308 var sv *types.VirtualNodeRef 13309 if *v == nil { 13310 sv = &types.VirtualNodeRef{} 13311 } else { 13312 sv = *v 13313 } 13314 13315 for key, value := range shape { 13316 switch key { 13317 case "arn": 13318 if value != nil { 13319 jtv, ok := value.(string) 13320 if !ok { 13321 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 13322 } 13323 sv.Arn = ptr.String(jtv) 13324 } 13325 13326 case "createdAt": 13327 if value != nil { 13328 jtv, ok := value.(json.Number) 13329 if !ok { 13330 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13331 } 13332 f64, err := jtv.Float64() 13333 if err != nil { 13334 return err 13335 } 13336 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13337 } 13338 13339 case "lastUpdatedAt": 13340 if value != nil { 13341 jtv, ok := value.(json.Number) 13342 if !ok { 13343 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13344 } 13345 f64, err := jtv.Float64() 13346 if err != nil { 13347 return err 13348 } 13349 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13350 } 13351 13352 case "meshName": 13353 if value != nil { 13354 jtv, ok := value.(string) 13355 if !ok { 13356 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13357 } 13358 sv.MeshName = ptr.String(jtv) 13359 } 13360 13361 case "meshOwner": 13362 if value != nil { 13363 jtv, ok := value.(string) 13364 if !ok { 13365 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13366 } 13367 sv.MeshOwner = ptr.String(jtv) 13368 } 13369 13370 case "resourceOwner": 13371 if value != nil { 13372 jtv, ok := value.(string) 13373 if !ok { 13374 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13375 } 13376 sv.ResourceOwner = ptr.String(jtv) 13377 } 13378 13379 case "version": 13380 if value != nil { 13381 jtv, ok := value.(json.Number) 13382 if !ok { 13383 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 13384 } 13385 i64, err := jtv.Int64() 13386 if err != nil { 13387 return err 13388 } 13389 sv.Version = ptr.Int64(i64) 13390 } 13391 13392 case "virtualNodeName": 13393 if value != nil { 13394 jtv, ok := value.(string) 13395 if !ok { 13396 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13397 } 13398 sv.VirtualNodeName = ptr.String(jtv) 13399 } 13400 13401 default: 13402 _, _ = key, value 13403 13404 } 13405 } 13406 *v = sv 13407 return nil 13408} 13409 13410func awsRestjson1_deserializeDocumentVirtualNodeServiceProvider(v **types.VirtualNodeServiceProvider, value interface{}) error { 13411 if v == nil { 13412 return fmt.Errorf("unexpected nil of type %T", v) 13413 } 13414 if value == nil { 13415 return nil 13416 } 13417 13418 shape, ok := value.(map[string]interface{}) 13419 if !ok { 13420 return fmt.Errorf("unexpected JSON type %v", value) 13421 } 13422 13423 var sv *types.VirtualNodeServiceProvider 13424 if *v == nil { 13425 sv = &types.VirtualNodeServiceProvider{} 13426 } else { 13427 sv = *v 13428 } 13429 13430 for key, value := range shape { 13431 switch key { 13432 case "virtualNodeName": 13433 if value != nil { 13434 jtv, ok := value.(string) 13435 if !ok { 13436 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13437 } 13438 sv.VirtualNodeName = ptr.String(jtv) 13439 } 13440 13441 default: 13442 _, _ = key, value 13443 13444 } 13445 } 13446 *v = sv 13447 return nil 13448} 13449 13450func awsRestjson1_deserializeDocumentVirtualNodeSpec(v **types.VirtualNodeSpec, value interface{}) error { 13451 if v == nil { 13452 return fmt.Errorf("unexpected nil of type %T", v) 13453 } 13454 if value == nil { 13455 return nil 13456 } 13457 13458 shape, ok := value.(map[string]interface{}) 13459 if !ok { 13460 return fmt.Errorf("unexpected JSON type %v", value) 13461 } 13462 13463 var sv *types.VirtualNodeSpec 13464 if *v == nil { 13465 sv = &types.VirtualNodeSpec{} 13466 } else { 13467 sv = *v 13468 } 13469 13470 for key, value := range shape { 13471 switch key { 13472 case "backendDefaults": 13473 if err := awsRestjson1_deserializeDocumentBackendDefaults(&sv.BackendDefaults, value); err != nil { 13474 return err 13475 } 13476 13477 case "backends": 13478 if err := awsRestjson1_deserializeDocumentBackends(&sv.Backends, value); err != nil { 13479 return err 13480 } 13481 13482 case "listeners": 13483 if err := awsRestjson1_deserializeDocumentListeners(&sv.Listeners, value); err != nil { 13484 return err 13485 } 13486 13487 case "logging": 13488 if err := awsRestjson1_deserializeDocumentLogging(&sv.Logging, value); err != nil { 13489 return err 13490 } 13491 13492 case "serviceDiscovery": 13493 if err := awsRestjson1_deserializeDocumentServiceDiscovery(&sv.ServiceDiscovery, value); err != nil { 13494 return err 13495 } 13496 13497 default: 13498 _, _ = key, value 13499 13500 } 13501 } 13502 *v = sv 13503 return nil 13504} 13505 13506func awsRestjson1_deserializeDocumentVirtualNodeStatus(v **types.VirtualNodeStatus, value interface{}) error { 13507 if v == nil { 13508 return fmt.Errorf("unexpected nil of type %T", v) 13509 } 13510 if value == nil { 13511 return nil 13512 } 13513 13514 shape, ok := value.(map[string]interface{}) 13515 if !ok { 13516 return fmt.Errorf("unexpected JSON type %v", value) 13517 } 13518 13519 var sv *types.VirtualNodeStatus 13520 if *v == nil { 13521 sv = &types.VirtualNodeStatus{} 13522 } else { 13523 sv = *v 13524 } 13525 13526 for key, value := range shape { 13527 switch key { 13528 case "status": 13529 if value != nil { 13530 jtv, ok := value.(string) 13531 if !ok { 13532 return fmt.Errorf("expected VirtualNodeStatusCode to be of type string, got %T instead", value) 13533 } 13534 sv.Status = types.VirtualNodeStatusCode(jtv) 13535 } 13536 13537 default: 13538 _, _ = key, value 13539 13540 } 13541 } 13542 *v = sv 13543 return nil 13544} 13545 13546func awsRestjson1_deserializeDocumentVirtualNodeTcpConnectionPool(v **types.VirtualNodeTcpConnectionPool, value interface{}) error { 13547 if v == nil { 13548 return fmt.Errorf("unexpected nil of type %T", v) 13549 } 13550 if value == nil { 13551 return nil 13552 } 13553 13554 shape, ok := value.(map[string]interface{}) 13555 if !ok { 13556 return fmt.Errorf("unexpected JSON type %v", value) 13557 } 13558 13559 var sv *types.VirtualNodeTcpConnectionPool 13560 if *v == nil { 13561 sv = &types.VirtualNodeTcpConnectionPool{} 13562 } else { 13563 sv = *v 13564 } 13565 13566 for key, value := range shape { 13567 switch key { 13568 case "maxConnections": 13569 if value != nil { 13570 jtv, ok := value.(json.Number) 13571 if !ok { 13572 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 13573 } 13574 i64, err := jtv.Int64() 13575 if err != nil { 13576 return err 13577 } 13578 sv.MaxConnections = int32(i64) 13579 } 13580 13581 default: 13582 _, _ = key, value 13583 13584 } 13585 } 13586 *v = sv 13587 return nil 13588} 13589 13590func awsRestjson1_deserializeDocumentVirtualRouterData(v **types.VirtualRouterData, value interface{}) error { 13591 if v == nil { 13592 return fmt.Errorf("unexpected nil of type %T", v) 13593 } 13594 if value == nil { 13595 return nil 13596 } 13597 13598 shape, ok := value.(map[string]interface{}) 13599 if !ok { 13600 return fmt.Errorf("unexpected JSON type %v", value) 13601 } 13602 13603 var sv *types.VirtualRouterData 13604 if *v == nil { 13605 sv = &types.VirtualRouterData{} 13606 } else { 13607 sv = *v 13608 } 13609 13610 for key, value := range shape { 13611 switch key { 13612 case "meshName": 13613 if value != nil { 13614 jtv, ok := value.(string) 13615 if !ok { 13616 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13617 } 13618 sv.MeshName = ptr.String(jtv) 13619 } 13620 13621 case "metadata": 13622 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 13623 return err 13624 } 13625 13626 case "spec": 13627 if err := awsRestjson1_deserializeDocumentVirtualRouterSpec(&sv.Spec, value); err != nil { 13628 return err 13629 } 13630 13631 case "status": 13632 if err := awsRestjson1_deserializeDocumentVirtualRouterStatus(&sv.Status, value); err != nil { 13633 return err 13634 } 13635 13636 case "virtualRouterName": 13637 if value != nil { 13638 jtv, ok := value.(string) 13639 if !ok { 13640 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13641 } 13642 sv.VirtualRouterName = ptr.String(jtv) 13643 } 13644 13645 default: 13646 _, _ = key, value 13647 13648 } 13649 } 13650 *v = sv 13651 return nil 13652} 13653 13654func awsRestjson1_deserializeDocumentVirtualRouterList(v *[]types.VirtualRouterRef, value interface{}) error { 13655 if v == nil { 13656 return fmt.Errorf("unexpected nil of type %T", v) 13657 } 13658 if value == nil { 13659 return nil 13660 } 13661 13662 shape, ok := value.([]interface{}) 13663 if !ok { 13664 return fmt.Errorf("unexpected JSON type %v", value) 13665 } 13666 13667 var cv []types.VirtualRouterRef 13668 if *v == nil { 13669 cv = []types.VirtualRouterRef{} 13670 } else { 13671 cv = *v 13672 } 13673 13674 for _, value := range shape { 13675 var col types.VirtualRouterRef 13676 destAddr := &col 13677 if err := awsRestjson1_deserializeDocumentVirtualRouterRef(&destAddr, value); err != nil { 13678 return err 13679 } 13680 col = *destAddr 13681 cv = append(cv, col) 13682 13683 } 13684 *v = cv 13685 return nil 13686} 13687 13688func awsRestjson1_deserializeDocumentVirtualRouterListener(v **types.VirtualRouterListener, value interface{}) error { 13689 if v == nil { 13690 return fmt.Errorf("unexpected nil of type %T", v) 13691 } 13692 if value == nil { 13693 return nil 13694 } 13695 13696 shape, ok := value.(map[string]interface{}) 13697 if !ok { 13698 return fmt.Errorf("unexpected JSON type %v", value) 13699 } 13700 13701 var sv *types.VirtualRouterListener 13702 if *v == nil { 13703 sv = &types.VirtualRouterListener{} 13704 } else { 13705 sv = *v 13706 } 13707 13708 for key, value := range shape { 13709 switch key { 13710 case "portMapping": 13711 if err := awsRestjson1_deserializeDocumentPortMapping(&sv.PortMapping, value); err != nil { 13712 return err 13713 } 13714 13715 default: 13716 _, _ = key, value 13717 13718 } 13719 } 13720 *v = sv 13721 return nil 13722} 13723 13724func awsRestjson1_deserializeDocumentVirtualRouterListeners(v *[]types.VirtualRouterListener, value interface{}) error { 13725 if v == nil { 13726 return fmt.Errorf("unexpected nil of type %T", v) 13727 } 13728 if value == nil { 13729 return nil 13730 } 13731 13732 shape, ok := value.([]interface{}) 13733 if !ok { 13734 return fmt.Errorf("unexpected JSON type %v", value) 13735 } 13736 13737 var cv []types.VirtualRouterListener 13738 if *v == nil { 13739 cv = []types.VirtualRouterListener{} 13740 } else { 13741 cv = *v 13742 } 13743 13744 for _, value := range shape { 13745 var col types.VirtualRouterListener 13746 destAddr := &col 13747 if err := awsRestjson1_deserializeDocumentVirtualRouterListener(&destAddr, value); err != nil { 13748 return err 13749 } 13750 col = *destAddr 13751 cv = append(cv, col) 13752 13753 } 13754 *v = cv 13755 return nil 13756} 13757 13758func awsRestjson1_deserializeDocumentVirtualRouterRef(v **types.VirtualRouterRef, value interface{}) error { 13759 if v == nil { 13760 return fmt.Errorf("unexpected nil of type %T", v) 13761 } 13762 if value == nil { 13763 return nil 13764 } 13765 13766 shape, ok := value.(map[string]interface{}) 13767 if !ok { 13768 return fmt.Errorf("unexpected JSON type %v", value) 13769 } 13770 13771 var sv *types.VirtualRouterRef 13772 if *v == nil { 13773 sv = &types.VirtualRouterRef{} 13774 } else { 13775 sv = *v 13776 } 13777 13778 for key, value := range shape { 13779 switch key { 13780 case "arn": 13781 if value != nil { 13782 jtv, ok := value.(string) 13783 if !ok { 13784 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 13785 } 13786 sv.Arn = ptr.String(jtv) 13787 } 13788 13789 case "createdAt": 13790 if value != nil { 13791 jtv, ok := value.(json.Number) 13792 if !ok { 13793 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13794 } 13795 f64, err := jtv.Float64() 13796 if err != nil { 13797 return err 13798 } 13799 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13800 } 13801 13802 case "lastUpdatedAt": 13803 if value != nil { 13804 jtv, ok := value.(json.Number) 13805 if !ok { 13806 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13807 } 13808 f64, err := jtv.Float64() 13809 if err != nil { 13810 return err 13811 } 13812 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13813 } 13814 13815 case "meshName": 13816 if value != nil { 13817 jtv, ok := value.(string) 13818 if !ok { 13819 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13820 } 13821 sv.MeshName = ptr.String(jtv) 13822 } 13823 13824 case "meshOwner": 13825 if value != nil { 13826 jtv, ok := value.(string) 13827 if !ok { 13828 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13829 } 13830 sv.MeshOwner = ptr.String(jtv) 13831 } 13832 13833 case "resourceOwner": 13834 if value != nil { 13835 jtv, ok := value.(string) 13836 if !ok { 13837 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13838 } 13839 sv.ResourceOwner = ptr.String(jtv) 13840 } 13841 13842 case "version": 13843 if value != nil { 13844 jtv, ok := value.(json.Number) 13845 if !ok { 13846 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 13847 } 13848 i64, err := jtv.Int64() 13849 if err != nil { 13850 return err 13851 } 13852 sv.Version = ptr.Int64(i64) 13853 } 13854 13855 case "virtualRouterName": 13856 if value != nil { 13857 jtv, ok := value.(string) 13858 if !ok { 13859 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13860 } 13861 sv.VirtualRouterName = ptr.String(jtv) 13862 } 13863 13864 default: 13865 _, _ = key, value 13866 13867 } 13868 } 13869 *v = sv 13870 return nil 13871} 13872 13873func awsRestjson1_deserializeDocumentVirtualRouterServiceProvider(v **types.VirtualRouterServiceProvider, value interface{}) error { 13874 if v == nil { 13875 return fmt.Errorf("unexpected nil of type %T", v) 13876 } 13877 if value == nil { 13878 return nil 13879 } 13880 13881 shape, ok := value.(map[string]interface{}) 13882 if !ok { 13883 return fmt.Errorf("unexpected JSON type %v", value) 13884 } 13885 13886 var sv *types.VirtualRouterServiceProvider 13887 if *v == nil { 13888 sv = &types.VirtualRouterServiceProvider{} 13889 } else { 13890 sv = *v 13891 } 13892 13893 for key, value := range shape { 13894 switch key { 13895 case "virtualRouterName": 13896 if value != nil { 13897 jtv, ok := value.(string) 13898 if !ok { 13899 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13900 } 13901 sv.VirtualRouterName = ptr.String(jtv) 13902 } 13903 13904 default: 13905 _, _ = key, value 13906 13907 } 13908 } 13909 *v = sv 13910 return nil 13911} 13912 13913func awsRestjson1_deserializeDocumentVirtualRouterSpec(v **types.VirtualRouterSpec, value interface{}) error { 13914 if v == nil { 13915 return fmt.Errorf("unexpected nil of type %T", v) 13916 } 13917 if value == nil { 13918 return nil 13919 } 13920 13921 shape, ok := value.(map[string]interface{}) 13922 if !ok { 13923 return fmt.Errorf("unexpected JSON type %v", value) 13924 } 13925 13926 var sv *types.VirtualRouterSpec 13927 if *v == nil { 13928 sv = &types.VirtualRouterSpec{} 13929 } else { 13930 sv = *v 13931 } 13932 13933 for key, value := range shape { 13934 switch key { 13935 case "listeners": 13936 if err := awsRestjson1_deserializeDocumentVirtualRouterListeners(&sv.Listeners, value); err != nil { 13937 return err 13938 } 13939 13940 default: 13941 _, _ = key, value 13942 13943 } 13944 } 13945 *v = sv 13946 return nil 13947} 13948 13949func awsRestjson1_deserializeDocumentVirtualRouterStatus(v **types.VirtualRouterStatus, value interface{}) error { 13950 if v == nil { 13951 return fmt.Errorf("unexpected nil of type %T", v) 13952 } 13953 if value == nil { 13954 return nil 13955 } 13956 13957 shape, ok := value.(map[string]interface{}) 13958 if !ok { 13959 return fmt.Errorf("unexpected JSON type %v", value) 13960 } 13961 13962 var sv *types.VirtualRouterStatus 13963 if *v == nil { 13964 sv = &types.VirtualRouterStatus{} 13965 } else { 13966 sv = *v 13967 } 13968 13969 for key, value := range shape { 13970 switch key { 13971 case "status": 13972 if value != nil { 13973 jtv, ok := value.(string) 13974 if !ok { 13975 return fmt.Errorf("expected VirtualRouterStatusCode to be of type string, got %T instead", value) 13976 } 13977 sv.Status = types.VirtualRouterStatusCode(jtv) 13978 } 13979 13980 default: 13981 _, _ = key, value 13982 13983 } 13984 } 13985 *v = sv 13986 return nil 13987} 13988 13989func awsRestjson1_deserializeDocumentVirtualServiceBackend(v **types.VirtualServiceBackend, value interface{}) error { 13990 if v == nil { 13991 return fmt.Errorf("unexpected nil of type %T", v) 13992 } 13993 if value == nil { 13994 return nil 13995 } 13996 13997 shape, ok := value.(map[string]interface{}) 13998 if !ok { 13999 return fmt.Errorf("unexpected JSON type %v", value) 14000 } 14001 14002 var sv *types.VirtualServiceBackend 14003 if *v == nil { 14004 sv = &types.VirtualServiceBackend{} 14005 } else { 14006 sv = *v 14007 } 14008 14009 for key, value := range shape { 14010 switch key { 14011 case "clientPolicy": 14012 if err := awsRestjson1_deserializeDocumentClientPolicy(&sv.ClientPolicy, value); err != nil { 14013 return err 14014 } 14015 14016 case "virtualServiceName": 14017 if value != nil { 14018 jtv, ok := value.(string) 14019 if !ok { 14020 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 14021 } 14022 sv.VirtualServiceName = ptr.String(jtv) 14023 } 14024 14025 default: 14026 _, _ = key, value 14027 14028 } 14029 } 14030 *v = sv 14031 return nil 14032} 14033 14034func awsRestjson1_deserializeDocumentVirtualServiceData(v **types.VirtualServiceData, value interface{}) error { 14035 if v == nil { 14036 return fmt.Errorf("unexpected nil of type %T", v) 14037 } 14038 if value == nil { 14039 return nil 14040 } 14041 14042 shape, ok := value.(map[string]interface{}) 14043 if !ok { 14044 return fmt.Errorf("unexpected JSON type %v", value) 14045 } 14046 14047 var sv *types.VirtualServiceData 14048 if *v == nil { 14049 sv = &types.VirtualServiceData{} 14050 } else { 14051 sv = *v 14052 } 14053 14054 for key, value := range shape { 14055 switch key { 14056 case "meshName": 14057 if value != nil { 14058 jtv, ok := value.(string) 14059 if !ok { 14060 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14061 } 14062 sv.MeshName = ptr.String(jtv) 14063 } 14064 14065 case "metadata": 14066 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 14067 return err 14068 } 14069 14070 case "spec": 14071 if err := awsRestjson1_deserializeDocumentVirtualServiceSpec(&sv.Spec, value); err != nil { 14072 return err 14073 } 14074 14075 case "status": 14076 if err := awsRestjson1_deserializeDocumentVirtualServiceStatus(&sv.Status, value); err != nil { 14077 return err 14078 } 14079 14080 case "virtualServiceName": 14081 if value != nil { 14082 jtv, ok := value.(string) 14083 if !ok { 14084 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 14085 } 14086 sv.VirtualServiceName = ptr.String(jtv) 14087 } 14088 14089 default: 14090 _, _ = key, value 14091 14092 } 14093 } 14094 *v = sv 14095 return nil 14096} 14097 14098func awsRestjson1_deserializeDocumentVirtualServiceList(v *[]types.VirtualServiceRef, value interface{}) error { 14099 if v == nil { 14100 return fmt.Errorf("unexpected nil of type %T", v) 14101 } 14102 if value == nil { 14103 return nil 14104 } 14105 14106 shape, ok := value.([]interface{}) 14107 if !ok { 14108 return fmt.Errorf("unexpected JSON type %v", value) 14109 } 14110 14111 var cv []types.VirtualServiceRef 14112 if *v == nil { 14113 cv = []types.VirtualServiceRef{} 14114 } else { 14115 cv = *v 14116 } 14117 14118 for _, value := range shape { 14119 var col types.VirtualServiceRef 14120 destAddr := &col 14121 if err := awsRestjson1_deserializeDocumentVirtualServiceRef(&destAddr, value); err != nil { 14122 return err 14123 } 14124 col = *destAddr 14125 cv = append(cv, col) 14126 14127 } 14128 *v = cv 14129 return nil 14130} 14131 14132func awsRestjson1_deserializeDocumentVirtualServiceProvider(v *types.VirtualServiceProvider, value interface{}) error { 14133 if v == nil { 14134 return fmt.Errorf("unexpected nil of type %T", v) 14135 } 14136 if value == nil { 14137 return nil 14138 } 14139 14140 shape, ok := value.(map[string]interface{}) 14141 if !ok { 14142 return fmt.Errorf("unexpected JSON type %v", value) 14143 } 14144 14145 var uv types.VirtualServiceProvider 14146loop: 14147 for key, value := range shape { 14148 if value == nil { 14149 continue 14150 } 14151 switch key { 14152 case "virtualNode": 14153 var mv types.VirtualNodeServiceProvider 14154 destAddr := &mv 14155 if err := awsRestjson1_deserializeDocumentVirtualNodeServiceProvider(&destAddr, value); err != nil { 14156 return err 14157 } 14158 mv = *destAddr 14159 uv = &types.VirtualServiceProviderMemberVirtualNode{Value: mv} 14160 break loop 14161 14162 case "virtualRouter": 14163 var mv types.VirtualRouterServiceProvider 14164 destAddr := &mv 14165 if err := awsRestjson1_deserializeDocumentVirtualRouterServiceProvider(&destAddr, value); err != nil { 14166 return err 14167 } 14168 mv = *destAddr 14169 uv = &types.VirtualServiceProviderMemberVirtualRouter{Value: mv} 14170 break loop 14171 14172 default: 14173 uv = &types.UnknownUnionMember{Tag: key} 14174 break loop 14175 14176 } 14177 } 14178 *v = uv 14179 return nil 14180} 14181 14182func awsRestjson1_deserializeDocumentVirtualServiceRef(v **types.VirtualServiceRef, value interface{}) error { 14183 if v == nil { 14184 return fmt.Errorf("unexpected nil of type %T", v) 14185 } 14186 if value == nil { 14187 return nil 14188 } 14189 14190 shape, ok := value.(map[string]interface{}) 14191 if !ok { 14192 return fmt.Errorf("unexpected JSON type %v", value) 14193 } 14194 14195 var sv *types.VirtualServiceRef 14196 if *v == nil { 14197 sv = &types.VirtualServiceRef{} 14198 } else { 14199 sv = *v 14200 } 14201 14202 for key, value := range shape { 14203 switch key { 14204 case "arn": 14205 if value != nil { 14206 jtv, ok := value.(string) 14207 if !ok { 14208 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14209 } 14210 sv.Arn = ptr.String(jtv) 14211 } 14212 14213 case "createdAt": 14214 if value != nil { 14215 jtv, ok := value.(json.Number) 14216 if !ok { 14217 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14218 } 14219 f64, err := jtv.Float64() 14220 if err != nil { 14221 return err 14222 } 14223 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14224 } 14225 14226 case "lastUpdatedAt": 14227 if value != nil { 14228 jtv, ok := value.(json.Number) 14229 if !ok { 14230 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14231 } 14232 f64, err := jtv.Float64() 14233 if err != nil { 14234 return err 14235 } 14236 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14237 } 14238 14239 case "meshName": 14240 if value != nil { 14241 jtv, ok := value.(string) 14242 if !ok { 14243 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14244 } 14245 sv.MeshName = ptr.String(jtv) 14246 } 14247 14248 case "meshOwner": 14249 if value != nil { 14250 jtv, ok := value.(string) 14251 if !ok { 14252 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14253 } 14254 sv.MeshOwner = ptr.String(jtv) 14255 } 14256 14257 case "resourceOwner": 14258 if value != nil { 14259 jtv, ok := value.(string) 14260 if !ok { 14261 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14262 } 14263 sv.ResourceOwner = ptr.String(jtv) 14264 } 14265 14266 case "version": 14267 if value != nil { 14268 jtv, ok := value.(json.Number) 14269 if !ok { 14270 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 14271 } 14272 i64, err := jtv.Int64() 14273 if err != nil { 14274 return err 14275 } 14276 sv.Version = ptr.Int64(i64) 14277 } 14278 14279 case "virtualServiceName": 14280 if value != nil { 14281 jtv, ok := value.(string) 14282 if !ok { 14283 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 14284 } 14285 sv.VirtualServiceName = ptr.String(jtv) 14286 } 14287 14288 default: 14289 _, _ = key, value 14290 14291 } 14292 } 14293 *v = sv 14294 return nil 14295} 14296 14297func awsRestjson1_deserializeDocumentVirtualServiceSpec(v **types.VirtualServiceSpec, value interface{}) error { 14298 if v == nil { 14299 return fmt.Errorf("unexpected nil of type %T", v) 14300 } 14301 if value == nil { 14302 return nil 14303 } 14304 14305 shape, ok := value.(map[string]interface{}) 14306 if !ok { 14307 return fmt.Errorf("unexpected JSON type %v", value) 14308 } 14309 14310 var sv *types.VirtualServiceSpec 14311 if *v == nil { 14312 sv = &types.VirtualServiceSpec{} 14313 } else { 14314 sv = *v 14315 } 14316 14317 for key, value := range shape { 14318 switch key { 14319 case "provider": 14320 if err := awsRestjson1_deserializeDocumentVirtualServiceProvider(&sv.Provider, value); err != nil { 14321 return err 14322 } 14323 14324 default: 14325 _, _ = key, value 14326 14327 } 14328 } 14329 *v = sv 14330 return nil 14331} 14332 14333func awsRestjson1_deserializeDocumentVirtualServiceStatus(v **types.VirtualServiceStatus, value interface{}) error { 14334 if v == nil { 14335 return fmt.Errorf("unexpected nil of type %T", v) 14336 } 14337 if value == nil { 14338 return nil 14339 } 14340 14341 shape, ok := value.(map[string]interface{}) 14342 if !ok { 14343 return fmt.Errorf("unexpected JSON type %v", value) 14344 } 14345 14346 var sv *types.VirtualServiceStatus 14347 if *v == nil { 14348 sv = &types.VirtualServiceStatus{} 14349 } else { 14350 sv = *v 14351 } 14352 14353 for key, value := range shape { 14354 switch key { 14355 case "status": 14356 if value != nil { 14357 jtv, ok := value.(string) 14358 if !ok { 14359 return fmt.Errorf("expected VirtualServiceStatusCode to be of type string, got %T instead", value) 14360 } 14361 sv.Status = types.VirtualServiceStatusCode(jtv) 14362 } 14363 14364 default: 14365 _, _ = key, value 14366 14367 } 14368 } 14369 *v = sv 14370 return nil 14371} 14372 14373func awsRestjson1_deserializeDocumentWeightedTarget(v **types.WeightedTarget, value interface{}) error { 14374 if v == nil { 14375 return fmt.Errorf("unexpected nil of type %T", v) 14376 } 14377 if value == nil { 14378 return nil 14379 } 14380 14381 shape, ok := value.(map[string]interface{}) 14382 if !ok { 14383 return fmt.Errorf("unexpected JSON type %v", value) 14384 } 14385 14386 var sv *types.WeightedTarget 14387 if *v == nil { 14388 sv = &types.WeightedTarget{} 14389 } else { 14390 sv = *v 14391 } 14392 14393 for key, value := range shape { 14394 switch key { 14395 case "virtualNode": 14396 if value != nil { 14397 jtv, ok := value.(string) 14398 if !ok { 14399 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14400 } 14401 sv.VirtualNode = ptr.String(jtv) 14402 } 14403 14404 case "weight": 14405 if value != nil { 14406 jtv, ok := value.(json.Number) 14407 if !ok { 14408 return fmt.Errorf("expected PercentInt to be json.Number, got %T instead", value) 14409 } 14410 i64, err := jtv.Int64() 14411 if err != nil { 14412 return err 14413 } 14414 sv.Weight = int32(i64) 14415 } 14416 14417 default: 14418 _, _ = key, value 14419 14420 } 14421 } 14422 *v = sv 14423 return nil 14424} 14425 14426func awsRestjson1_deserializeDocumentWeightedTargets(v *[]types.WeightedTarget, value interface{}) error { 14427 if v == nil { 14428 return fmt.Errorf("unexpected nil of type %T", v) 14429 } 14430 if value == nil { 14431 return nil 14432 } 14433 14434 shape, ok := value.([]interface{}) 14435 if !ok { 14436 return fmt.Errorf("unexpected JSON type %v", value) 14437 } 14438 14439 var cv []types.WeightedTarget 14440 if *v == nil { 14441 cv = []types.WeightedTarget{} 14442 } else { 14443 cv = *v 14444 } 14445 14446 for _, value := range shape { 14447 var col types.WeightedTarget 14448 destAddr := &col 14449 if err := awsRestjson1_deserializeDocumentWeightedTarget(&destAddr, value); err != nil { 14450 return err 14451 } 14452 col = *destAddr 14453 cv = append(cv, col) 14454 14455 } 14456 *v = cv 14457 return nil 14458} 14459