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 case "responseType": 7161 if value != nil { 7162 jtv, ok := value.(string) 7163 if !ok { 7164 return fmt.Errorf("expected DnsResponseType to be of type string, got %T instead", value) 7165 } 7166 sv.ResponseType = types.DnsResponseType(jtv) 7167 } 7168 7169 default: 7170 _, _ = key, value 7171 7172 } 7173 } 7174 *v = sv 7175 return nil 7176} 7177 7178func awsRestjson1_deserializeDocumentDuration(v **types.Duration, value interface{}) error { 7179 if v == nil { 7180 return fmt.Errorf("unexpected nil of type %T", v) 7181 } 7182 if value == nil { 7183 return nil 7184 } 7185 7186 shape, ok := value.(map[string]interface{}) 7187 if !ok { 7188 return fmt.Errorf("unexpected JSON type %v", value) 7189 } 7190 7191 var sv *types.Duration 7192 if *v == nil { 7193 sv = &types.Duration{} 7194 } else { 7195 sv = *v 7196 } 7197 7198 for key, value := range shape { 7199 switch key { 7200 case "unit": 7201 if value != nil { 7202 jtv, ok := value.(string) 7203 if !ok { 7204 return fmt.Errorf("expected DurationUnit to be of type string, got %T instead", value) 7205 } 7206 sv.Unit = types.DurationUnit(jtv) 7207 } 7208 7209 case "value": 7210 if value != nil { 7211 jtv, ok := value.(json.Number) 7212 if !ok { 7213 return fmt.Errorf("expected DurationValue to be json.Number, got %T instead", value) 7214 } 7215 i64, err := jtv.Int64() 7216 if err != nil { 7217 return err 7218 } 7219 sv.Value = ptr.Int64(i64) 7220 } 7221 7222 default: 7223 _, _ = key, value 7224 7225 } 7226 } 7227 *v = sv 7228 return nil 7229} 7230 7231func awsRestjson1_deserializeDocumentEgressFilter(v **types.EgressFilter, value interface{}) error { 7232 if v == nil { 7233 return fmt.Errorf("unexpected nil of type %T", v) 7234 } 7235 if value == nil { 7236 return nil 7237 } 7238 7239 shape, ok := value.(map[string]interface{}) 7240 if !ok { 7241 return fmt.Errorf("unexpected JSON type %v", value) 7242 } 7243 7244 var sv *types.EgressFilter 7245 if *v == nil { 7246 sv = &types.EgressFilter{} 7247 } else { 7248 sv = *v 7249 } 7250 7251 for key, value := range shape { 7252 switch key { 7253 case "type": 7254 if value != nil { 7255 jtv, ok := value.(string) 7256 if !ok { 7257 return fmt.Errorf("expected EgressFilterType to be of type string, got %T instead", value) 7258 } 7259 sv.Type = types.EgressFilterType(jtv) 7260 } 7261 7262 default: 7263 _, _ = key, value 7264 7265 } 7266 } 7267 *v = sv 7268 return nil 7269} 7270 7271func awsRestjson1_deserializeDocumentFileAccessLog(v **types.FileAccessLog, value interface{}) error { 7272 if v == nil { 7273 return fmt.Errorf("unexpected nil of type %T", v) 7274 } 7275 if value == nil { 7276 return nil 7277 } 7278 7279 shape, ok := value.(map[string]interface{}) 7280 if !ok { 7281 return fmt.Errorf("unexpected JSON type %v", value) 7282 } 7283 7284 var sv *types.FileAccessLog 7285 if *v == nil { 7286 sv = &types.FileAccessLog{} 7287 } else { 7288 sv = *v 7289 } 7290 7291 for key, value := range shape { 7292 switch key { 7293 case "path": 7294 if value != nil { 7295 jtv, ok := value.(string) 7296 if !ok { 7297 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 7298 } 7299 sv.Path = ptr.String(jtv) 7300 } 7301 7302 default: 7303 _, _ = key, value 7304 7305 } 7306 } 7307 *v = sv 7308 return nil 7309} 7310 7311func awsRestjson1_deserializeDocumentForbiddenException(v **types.ForbiddenException, value interface{}) error { 7312 if v == nil { 7313 return fmt.Errorf("unexpected nil of type %T", v) 7314 } 7315 if value == nil { 7316 return nil 7317 } 7318 7319 shape, ok := value.(map[string]interface{}) 7320 if !ok { 7321 return fmt.Errorf("unexpected JSON type %v", value) 7322 } 7323 7324 var sv *types.ForbiddenException 7325 if *v == nil { 7326 sv = &types.ForbiddenException{} 7327 } else { 7328 sv = *v 7329 } 7330 7331 for key, value := range shape { 7332 switch key { 7333 case "message": 7334 if value != nil { 7335 jtv, ok := value.(string) 7336 if !ok { 7337 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7338 } 7339 sv.Message = ptr.String(jtv) 7340 } 7341 7342 default: 7343 _, _ = key, value 7344 7345 } 7346 } 7347 *v = sv 7348 return nil 7349} 7350 7351func awsRestjson1_deserializeDocumentGatewayRouteData(v **types.GatewayRouteData, value interface{}) error { 7352 if v == nil { 7353 return fmt.Errorf("unexpected nil of type %T", v) 7354 } 7355 if value == nil { 7356 return nil 7357 } 7358 7359 shape, ok := value.(map[string]interface{}) 7360 if !ok { 7361 return fmt.Errorf("unexpected JSON type %v", value) 7362 } 7363 7364 var sv *types.GatewayRouteData 7365 if *v == nil { 7366 sv = &types.GatewayRouteData{} 7367 } else { 7368 sv = *v 7369 } 7370 7371 for key, value := range shape { 7372 switch key { 7373 case "gatewayRouteName": 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.GatewayRouteName = ptr.String(jtv) 7380 } 7381 7382 case "meshName": 7383 if value != nil { 7384 jtv, ok := value.(string) 7385 if !ok { 7386 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7387 } 7388 sv.MeshName = ptr.String(jtv) 7389 } 7390 7391 case "metadata": 7392 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 7393 return err 7394 } 7395 7396 case "spec": 7397 if err := awsRestjson1_deserializeDocumentGatewayRouteSpec(&sv.Spec, value); err != nil { 7398 return err 7399 } 7400 7401 case "status": 7402 if err := awsRestjson1_deserializeDocumentGatewayRouteStatus(&sv.Status, value); err != nil { 7403 return err 7404 } 7405 7406 case "virtualGatewayName": 7407 if value != nil { 7408 jtv, ok := value.(string) 7409 if !ok { 7410 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7411 } 7412 sv.VirtualGatewayName = ptr.String(jtv) 7413 } 7414 7415 default: 7416 _, _ = key, value 7417 7418 } 7419 } 7420 *v = sv 7421 return nil 7422} 7423 7424func awsRestjson1_deserializeDocumentGatewayRouteHostnameMatch(v **types.GatewayRouteHostnameMatch, value interface{}) error { 7425 if v == nil { 7426 return fmt.Errorf("unexpected nil of type %T", v) 7427 } 7428 if value == nil { 7429 return nil 7430 } 7431 7432 shape, ok := value.(map[string]interface{}) 7433 if !ok { 7434 return fmt.Errorf("unexpected JSON type %v", value) 7435 } 7436 7437 var sv *types.GatewayRouteHostnameMatch 7438 if *v == nil { 7439 sv = &types.GatewayRouteHostnameMatch{} 7440 } else { 7441 sv = *v 7442 } 7443 7444 for key, value := range shape { 7445 switch key { 7446 case "exact": 7447 if value != nil { 7448 jtv, ok := value.(string) 7449 if !ok { 7450 return fmt.Errorf("expected ExactHostName to be of type string, got %T instead", value) 7451 } 7452 sv.Exact = ptr.String(jtv) 7453 } 7454 7455 case "suffix": 7456 if value != nil { 7457 jtv, ok := value.(string) 7458 if !ok { 7459 return fmt.Errorf("expected SuffixHostname to be of type string, got %T instead", value) 7460 } 7461 sv.Suffix = ptr.String(jtv) 7462 } 7463 7464 default: 7465 _, _ = key, value 7466 7467 } 7468 } 7469 *v = sv 7470 return nil 7471} 7472 7473func awsRestjson1_deserializeDocumentGatewayRouteHostnameRewrite(v **types.GatewayRouteHostnameRewrite, value interface{}) error { 7474 if v == nil { 7475 return fmt.Errorf("unexpected nil of type %T", v) 7476 } 7477 if value == nil { 7478 return nil 7479 } 7480 7481 shape, ok := value.(map[string]interface{}) 7482 if !ok { 7483 return fmt.Errorf("unexpected JSON type %v", value) 7484 } 7485 7486 var sv *types.GatewayRouteHostnameRewrite 7487 if *v == nil { 7488 sv = &types.GatewayRouteHostnameRewrite{} 7489 } else { 7490 sv = *v 7491 } 7492 7493 for key, value := range shape { 7494 switch key { 7495 case "defaultTargetHostname": 7496 if value != nil { 7497 jtv, ok := value.(string) 7498 if !ok { 7499 return fmt.Errorf("expected DefaultGatewayRouteRewrite to be of type string, got %T instead", value) 7500 } 7501 sv.DefaultTargetHostname = types.DefaultGatewayRouteRewrite(jtv) 7502 } 7503 7504 default: 7505 _, _ = key, value 7506 7507 } 7508 } 7509 *v = sv 7510 return nil 7511} 7512 7513func awsRestjson1_deserializeDocumentGatewayRouteList(v *[]types.GatewayRouteRef, value interface{}) error { 7514 if v == nil { 7515 return fmt.Errorf("unexpected nil of type %T", v) 7516 } 7517 if value == nil { 7518 return nil 7519 } 7520 7521 shape, ok := value.([]interface{}) 7522 if !ok { 7523 return fmt.Errorf("unexpected JSON type %v", value) 7524 } 7525 7526 var cv []types.GatewayRouteRef 7527 if *v == nil { 7528 cv = []types.GatewayRouteRef{} 7529 } else { 7530 cv = *v 7531 } 7532 7533 for _, value := range shape { 7534 var col types.GatewayRouteRef 7535 destAddr := &col 7536 if err := awsRestjson1_deserializeDocumentGatewayRouteRef(&destAddr, value); err != nil { 7537 return err 7538 } 7539 col = *destAddr 7540 cv = append(cv, col) 7541 7542 } 7543 *v = cv 7544 return nil 7545} 7546 7547func awsRestjson1_deserializeDocumentGatewayRouteRef(v **types.GatewayRouteRef, value interface{}) error { 7548 if v == nil { 7549 return fmt.Errorf("unexpected nil of type %T", v) 7550 } 7551 if value == nil { 7552 return nil 7553 } 7554 7555 shape, ok := value.(map[string]interface{}) 7556 if !ok { 7557 return fmt.Errorf("unexpected JSON type %v", value) 7558 } 7559 7560 var sv *types.GatewayRouteRef 7561 if *v == nil { 7562 sv = &types.GatewayRouteRef{} 7563 } else { 7564 sv = *v 7565 } 7566 7567 for key, value := range shape { 7568 switch key { 7569 case "arn": 7570 if value != nil { 7571 jtv, ok := value.(string) 7572 if !ok { 7573 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7574 } 7575 sv.Arn = ptr.String(jtv) 7576 } 7577 7578 case "createdAt": 7579 if value != nil { 7580 switch jtv := value.(type) { 7581 case json.Number: 7582 f64, err := jtv.Float64() 7583 if err != nil { 7584 return err 7585 } 7586 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7587 7588 default: 7589 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 7590 7591 } 7592 } 7593 7594 case "gatewayRouteName": 7595 if value != nil { 7596 jtv, ok := value.(string) 7597 if !ok { 7598 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7599 } 7600 sv.GatewayRouteName = ptr.String(jtv) 7601 } 7602 7603 case "lastUpdatedAt": 7604 if value != nil { 7605 switch jtv := value.(type) { 7606 case json.Number: 7607 f64, err := jtv.Float64() 7608 if err != nil { 7609 return err 7610 } 7611 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7612 7613 default: 7614 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 7615 7616 } 7617 } 7618 7619 case "meshName": 7620 if value != nil { 7621 jtv, ok := value.(string) 7622 if !ok { 7623 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7624 } 7625 sv.MeshName = ptr.String(jtv) 7626 } 7627 7628 case "meshOwner": 7629 if value != nil { 7630 jtv, ok := value.(string) 7631 if !ok { 7632 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 7633 } 7634 sv.MeshOwner = ptr.String(jtv) 7635 } 7636 7637 case "resourceOwner": 7638 if value != nil { 7639 jtv, ok := value.(string) 7640 if !ok { 7641 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 7642 } 7643 sv.ResourceOwner = ptr.String(jtv) 7644 } 7645 7646 case "version": 7647 if value != nil { 7648 jtv, ok := value.(json.Number) 7649 if !ok { 7650 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 7651 } 7652 i64, err := jtv.Int64() 7653 if err != nil { 7654 return err 7655 } 7656 sv.Version = ptr.Int64(i64) 7657 } 7658 7659 case "virtualGatewayName": 7660 if value != nil { 7661 jtv, ok := value.(string) 7662 if !ok { 7663 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7664 } 7665 sv.VirtualGatewayName = ptr.String(jtv) 7666 } 7667 7668 default: 7669 _, _ = key, value 7670 7671 } 7672 } 7673 *v = sv 7674 return nil 7675} 7676 7677func awsRestjson1_deserializeDocumentGatewayRouteSpec(v **types.GatewayRouteSpec, value interface{}) error { 7678 if v == nil { 7679 return fmt.Errorf("unexpected nil of type %T", v) 7680 } 7681 if value == nil { 7682 return nil 7683 } 7684 7685 shape, ok := value.(map[string]interface{}) 7686 if !ok { 7687 return fmt.Errorf("unexpected JSON type %v", value) 7688 } 7689 7690 var sv *types.GatewayRouteSpec 7691 if *v == nil { 7692 sv = &types.GatewayRouteSpec{} 7693 } else { 7694 sv = *v 7695 } 7696 7697 for key, value := range shape { 7698 switch key { 7699 case "grpcRoute": 7700 if err := awsRestjson1_deserializeDocumentGrpcGatewayRoute(&sv.GrpcRoute, value); err != nil { 7701 return err 7702 } 7703 7704 case "http2Route": 7705 if err := awsRestjson1_deserializeDocumentHttpGatewayRoute(&sv.Http2Route, value); err != nil { 7706 return err 7707 } 7708 7709 case "httpRoute": 7710 if err := awsRestjson1_deserializeDocumentHttpGatewayRoute(&sv.HttpRoute, value); err != nil { 7711 return err 7712 } 7713 7714 case "priority": 7715 if value != nil { 7716 jtv, ok := value.(json.Number) 7717 if !ok { 7718 return fmt.Errorf("expected GatewayRoutePriority to be json.Number, got %T instead", value) 7719 } 7720 i64, err := jtv.Int64() 7721 if err != nil { 7722 return err 7723 } 7724 sv.Priority = ptr.Int32(int32(i64)) 7725 } 7726 7727 default: 7728 _, _ = key, value 7729 7730 } 7731 } 7732 *v = sv 7733 return nil 7734} 7735 7736func awsRestjson1_deserializeDocumentGatewayRouteStatus(v **types.GatewayRouteStatus, value interface{}) error { 7737 if v == nil { 7738 return fmt.Errorf("unexpected nil of type %T", v) 7739 } 7740 if value == nil { 7741 return nil 7742 } 7743 7744 shape, ok := value.(map[string]interface{}) 7745 if !ok { 7746 return fmt.Errorf("unexpected JSON type %v", value) 7747 } 7748 7749 var sv *types.GatewayRouteStatus 7750 if *v == nil { 7751 sv = &types.GatewayRouteStatus{} 7752 } else { 7753 sv = *v 7754 } 7755 7756 for key, value := range shape { 7757 switch key { 7758 case "status": 7759 if value != nil { 7760 jtv, ok := value.(string) 7761 if !ok { 7762 return fmt.Errorf("expected GatewayRouteStatusCode to be of type string, got %T instead", value) 7763 } 7764 sv.Status = types.GatewayRouteStatusCode(jtv) 7765 } 7766 7767 default: 7768 _, _ = key, value 7769 7770 } 7771 } 7772 *v = sv 7773 return nil 7774} 7775 7776func awsRestjson1_deserializeDocumentGatewayRouteTarget(v **types.GatewayRouteTarget, 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.GatewayRouteTarget 7790 if *v == nil { 7791 sv = &types.GatewayRouteTarget{} 7792 } else { 7793 sv = *v 7794 } 7795 7796 for key, value := range shape { 7797 switch key { 7798 case "virtualService": 7799 if err := awsRestjson1_deserializeDocumentGatewayRouteVirtualService(&sv.VirtualService, 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_deserializeDocumentGatewayRouteVirtualService(v **types.GatewayRouteVirtualService, 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.GatewayRouteVirtualService 7826 if *v == nil { 7827 sv = &types.GatewayRouteVirtualService{} 7828 } else { 7829 sv = *v 7830 } 7831 7832 for key, value := range shape { 7833 switch key { 7834 case "virtualServiceName": 7835 if value != nil { 7836 jtv, ok := value.(string) 7837 if !ok { 7838 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 7839 } 7840 sv.VirtualServiceName = ptr.String(jtv) 7841 } 7842 7843 default: 7844 _, _ = key, value 7845 7846 } 7847 } 7848 *v = sv 7849 return nil 7850} 7851 7852func awsRestjson1_deserializeDocumentGrpcGatewayRoute(v **types.GrpcGatewayRoute, 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.GrpcGatewayRoute 7866 if *v == nil { 7867 sv = &types.GrpcGatewayRoute{} 7868 } else { 7869 sv = *v 7870 } 7871 7872 for key, value := range shape { 7873 switch key { 7874 case "action": 7875 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteAction(&sv.Action, value); err != nil { 7876 return err 7877 } 7878 7879 case "match": 7880 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteMatch(&sv.Match, value); err != nil { 7881 return err 7882 } 7883 7884 default: 7885 _, _ = key, value 7886 7887 } 7888 } 7889 *v = sv 7890 return nil 7891} 7892 7893func awsRestjson1_deserializeDocumentGrpcGatewayRouteAction(v **types.GrpcGatewayRouteAction, value interface{}) error { 7894 if v == nil { 7895 return fmt.Errorf("unexpected nil of type %T", v) 7896 } 7897 if value == nil { 7898 return nil 7899 } 7900 7901 shape, ok := value.(map[string]interface{}) 7902 if !ok { 7903 return fmt.Errorf("unexpected JSON type %v", value) 7904 } 7905 7906 var sv *types.GrpcGatewayRouteAction 7907 if *v == nil { 7908 sv = &types.GrpcGatewayRouteAction{} 7909 } else { 7910 sv = *v 7911 } 7912 7913 for key, value := range shape { 7914 switch key { 7915 case "rewrite": 7916 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteRewrite(&sv.Rewrite, value); err != nil { 7917 return err 7918 } 7919 7920 case "target": 7921 if err := awsRestjson1_deserializeDocumentGatewayRouteTarget(&sv.Target, value); err != nil { 7922 return err 7923 } 7924 7925 default: 7926 _, _ = key, value 7927 7928 } 7929 } 7930 *v = sv 7931 return nil 7932} 7933 7934func awsRestjson1_deserializeDocumentGrpcGatewayRouteMatch(v **types.GrpcGatewayRouteMatch, value interface{}) error { 7935 if v == nil { 7936 return fmt.Errorf("unexpected nil of type %T", v) 7937 } 7938 if value == nil { 7939 return nil 7940 } 7941 7942 shape, ok := value.(map[string]interface{}) 7943 if !ok { 7944 return fmt.Errorf("unexpected JSON type %v", value) 7945 } 7946 7947 var sv *types.GrpcGatewayRouteMatch 7948 if *v == nil { 7949 sv = &types.GrpcGatewayRouteMatch{} 7950 } else { 7951 sv = *v 7952 } 7953 7954 for key, value := range shape { 7955 switch key { 7956 case "hostname": 7957 if err := awsRestjson1_deserializeDocumentGatewayRouteHostnameMatch(&sv.Hostname, value); err != nil { 7958 return err 7959 } 7960 7961 case "metadata": 7962 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteMetadataList(&sv.Metadata, value); err != nil { 7963 return err 7964 } 7965 7966 case "serviceName": 7967 if value != nil { 7968 jtv, ok := value.(string) 7969 if !ok { 7970 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 7971 } 7972 sv.ServiceName = ptr.String(jtv) 7973 } 7974 7975 default: 7976 _, _ = key, value 7977 7978 } 7979 } 7980 *v = sv 7981 return nil 7982} 7983 7984func awsRestjson1_deserializeDocumentGrpcGatewayRouteMetadata(v **types.GrpcGatewayRouteMetadata, value interface{}) error { 7985 if v == nil { 7986 return fmt.Errorf("unexpected nil of type %T", v) 7987 } 7988 if value == nil { 7989 return nil 7990 } 7991 7992 shape, ok := value.(map[string]interface{}) 7993 if !ok { 7994 return fmt.Errorf("unexpected JSON type %v", value) 7995 } 7996 7997 var sv *types.GrpcGatewayRouteMetadata 7998 if *v == nil { 7999 sv = &types.GrpcGatewayRouteMetadata{} 8000 } else { 8001 sv = *v 8002 } 8003 8004 for key, value := range shape { 8005 switch key { 8006 case "invert": 8007 if value != nil { 8008 jtv, ok := value.(bool) 8009 if !ok { 8010 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8011 } 8012 sv.Invert = ptr.Bool(jtv) 8013 } 8014 8015 case "match": 8016 if err := awsRestjson1_deserializeDocumentGrpcMetadataMatchMethod(&sv.Match, value); err != nil { 8017 return err 8018 } 8019 8020 case "name": 8021 if value != nil { 8022 jtv, ok := value.(string) 8023 if !ok { 8024 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 8025 } 8026 sv.Name = ptr.String(jtv) 8027 } 8028 8029 default: 8030 _, _ = key, value 8031 8032 } 8033 } 8034 *v = sv 8035 return nil 8036} 8037 8038func awsRestjson1_deserializeDocumentGrpcGatewayRouteMetadataList(v *[]types.GrpcGatewayRouteMetadata, value interface{}) error { 8039 if v == nil { 8040 return fmt.Errorf("unexpected nil of type %T", v) 8041 } 8042 if value == nil { 8043 return nil 8044 } 8045 8046 shape, ok := value.([]interface{}) 8047 if !ok { 8048 return fmt.Errorf("unexpected JSON type %v", value) 8049 } 8050 8051 var cv []types.GrpcGatewayRouteMetadata 8052 if *v == nil { 8053 cv = []types.GrpcGatewayRouteMetadata{} 8054 } else { 8055 cv = *v 8056 } 8057 8058 for _, value := range shape { 8059 var col types.GrpcGatewayRouteMetadata 8060 destAddr := &col 8061 if err := awsRestjson1_deserializeDocumentGrpcGatewayRouteMetadata(&destAddr, value); err != nil { 8062 return err 8063 } 8064 col = *destAddr 8065 cv = append(cv, col) 8066 8067 } 8068 *v = cv 8069 return nil 8070} 8071 8072func awsRestjson1_deserializeDocumentGrpcGatewayRouteRewrite(v **types.GrpcGatewayRouteRewrite, value interface{}) error { 8073 if v == nil { 8074 return fmt.Errorf("unexpected nil of type %T", v) 8075 } 8076 if value == nil { 8077 return nil 8078 } 8079 8080 shape, ok := value.(map[string]interface{}) 8081 if !ok { 8082 return fmt.Errorf("unexpected JSON type %v", value) 8083 } 8084 8085 var sv *types.GrpcGatewayRouteRewrite 8086 if *v == nil { 8087 sv = &types.GrpcGatewayRouteRewrite{} 8088 } else { 8089 sv = *v 8090 } 8091 8092 for key, value := range shape { 8093 switch key { 8094 case "hostname": 8095 if err := awsRestjson1_deserializeDocumentGatewayRouteHostnameRewrite(&sv.Hostname, value); err != nil { 8096 return err 8097 } 8098 8099 default: 8100 _, _ = key, value 8101 8102 } 8103 } 8104 *v = sv 8105 return nil 8106} 8107 8108func awsRestjson1_deserializeDocumentGrpcMetadataMatchMethod(v *types.GrpcMetadataMatchMethod, value interface{}) error { 8109 if v == nil { 8110 return fmt.Errorf("unexpected nil of type %T", v) 8111 } 8112 if value == nil { 8113 return nil 8114 } 8115 8116 shape, ok := value.(map[string]interface{}) 8117 if !ok { 8118 return fmt.Errorf("unexpected JSON type %v", value) 8119 } 8120 8121 var uv types.GrpcMetadataMatchMethod 8122loop: 8123 for key, value := range shape { 8124 if value == nil { 8125 continue 8126 } 8127 switch key { 8128 case "exact": 8129 var mv string 8130 if value != nil { 8131 jtv, ok := value.(string) 8132 if !ok { 8133 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8134 } 8135 mv = jtv 8136 } 8137 uv = &types.GrpcMetadataMatchMethodMemberExact{Value: mv} 8138 break loop 8139 8140 case "prefix": 8141 var mv string 8142 if value != nil { 8143 jtv, ok := value.(string) 8144 if !ok { 8145 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8146 } 8147 mv = jtv 8148 } 8149 uv = &types.GrpcMetadataMatchMethodMemberPrefix{Value: mv} 8150 break loop 8151 8152 case "range": 8153 var mv types.MatchRange 8154 destAddr := &mv 8155 if err := awsRestjson1_deserializeDocumentMatchRange(&destAddr, value); err != nil { 8156 return err 8157 } 8158 mv = *destAddr 8159 uv = &types.GrpcMetadataMatchMethodMemberRange{Value: mv} 8160 break loop 8161 8162 case "regex": 8163 var mv string 8164 if value != nil { 8165 jtv, ok := value.(string) 8166 if !ok { 8167 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8168 } 8169 mv = jtv 8170 } 8171 uv = &types.GrpcMetadataMatchMethodMemberRegex{Value: mv} 8172 break loop 8173 8174 case "suffix": 8175 var mv string 8176 if value != nil { 8177 jtv, ok := value.(string) 8178 if !ok { 8179 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8180 } 8181 mv = jtv 8182 } 8183 uv = &types.GrpcMetadataMatchMethodMemberSuffix{Value: mv} 8184 break loop 8185 8186 default: 8187 uv = &types.UnknownUnionMember{Tag: key} 8188 break loop 8189 8190 } 8191 } 8192 *v = uv 8193 return nil 8194} 8195 8196func awsRestjson1_deserializeDocumentGrpcRetryPolicy(v **types.GrpcRetryPolicy, value interface{}) error { 8197 if v == nil { 8198 return fmt.Errorf("unexpected nil of type %T", v) 8199 } 8200 if value == nil { 8201 return nil 8202 } 8203 8204 shape, ok := value.(map[string]interface{}) 8205 if !ok { 8206 return fmt.Errorf("unexpected JSON type %v", value) 8207 } 8208 8209 var sv *types.GrpcRetryPolicy 8210 if *v == nil { 8211 sv = &types.GrpcRetryPolicy{} 8212 } else { 8213 sv = *v 8214 } 8215 8216 for key, value := range shape { 8217 switch key { 8218 case "grpcRetryEvents": 8219 if err := awsRestjson1_deserializeDocumentGrpcRetryPolicyEvents(&sv.GrpcRetryEvents, value); err != nil { 8220 return err 8221 } 8222 8223 case "httpRetryEvents": 8224 if err := awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(&sv.HttpRetryEvents, value); err != nil { 8225 return err 8226 } 8227 8228 case "maxRetries": 8229 if value != nil { 8230 jtv, ok := value.(json.Number) 8231 if !ok { 8232 return fmt.Errorf("expected MaxRetries to be json.Number, got %T instead", value) 8233 } 8234 i64, err := jtv.Int64() 8235 if err != nil { 8236 return err 8237 } 8238 sv.MaxRetries = ptr.Int64(i64) 8239 } 8240 8241 case "perRetryTimeout": 8242 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRetryTimeout, value); err != nil { 8243 return err 8244 } 8245 8246 case "tcpRetryEvents": 8247 if err := awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(&sv.TcpRetryEvents, value); err != nil { 8248 return err 8249 } 8250 8251 default: 8252 _, _ = key, value 8253 8254 } 8255 } 8256 *v = sv 8257 return nil 8258} 8259 8260func awsRestjson1_deserializeDocumentGrpcRetryPolicyEvents(v *[]types.GrpcRetryPolicyEvent, value interface{}) error { 8261 if v == nil { 8262 return fmt.Errorf("unexpected nil of type %T", v) 8263 } 8264 if value == nil { 8265 return nil 8266 } 8267 8268 shape, ok := value.([]interface{}) 8269 if !ok { 8270 return fmt.Errorf("unexpected JSON type %v", value) 8271 } 8272 8273 var cv []types.GrpcRetryPolicyEvent 8274 if *v == nil { 8275 cv = []types.GrpcRetryPolicyEvent{} 8276 } else { 8277 cv = *v 8278 } 8279 8280 for _, value := range shape { 8281 var col types.GrpcRetryPolicyEvent 8282 if value != nil { 8283 jtv, ok := value.(string) 8284 if !ok { 8285 return fmt.Errorf("expected GrpcRetryPolicyEvent to be of type string, got %T instead", value) 8286 } 8287 col = types.GrpcRetryPolicyEvent(jtv) 8288 } 8289 cv = append(cv, col) 8290 8291 } 8292 *v = cv 8293 return nil 8294} 8295 8296func awsRestjson1_deserializeDocumentGrpcRoute(v **types.GrpcRoute, value interface{}) error { 8297 if v == nil { 8298 return fmt.Errorf("unexpected nil of type %T", v) 8299 } 8300 if value == nil { 8301 return nil 8302 } 8303 8304 shape, ok := value.(map[string]interface{}) 8305 if !ok { 8306 return fmt.Errorf("unexpected JSON type %v", value) 8307 } 8308 8309 var sv *types.GrpcRoute 8310 if *v == nil { 8311 sv = &types.GrpcRoute{} 8312 } else { 8313 sv = *v 8314 } 8315 8316 for key, value := range shape { 8317 switch key { 8318 case "action": 8319 if err := awsRestjson1_deserializeDocumentGrpcRouteAction(&sv.Action, value); err != nil { 8320 return err 8321 } 8322 8323 case "match": 8324 if err := awsRestjson1_deserializeDocumentGrpcRouteMatch(&sv.Match, value); err != nil { 8325 return err 8326 } 8327 8328 case "retryPolicy": 8329 if err := awsRestjson1_deserializeDocumentGrpcRetryPolicy(&sv.RetryPolicy, value); err != nil { 8330 return err 8331 } 8332 8333 case "timeout": 8334 if err := awsRestjson1_deserializeDocumentGrpcTimeout(&sv.Timeout, value); err != nil { 8335 return err 8336 } 8337 8338 default: 8339 _, _ = key, value 8340 8341 } 8342 } 8343 *v = sv 8344 return nil 8345} 8346 8347func awsRestjson1_deserializeDocumentGrpcRouteAction(v **types.GrpcRouteAction, value interface{}) error { 8348 if v == nil { 8349 return fmt.Errorf("unexpected nil of type %T", v) 8350 } 8351 if value == nil { 8352 return nil 8353 } 8354 8355 shape, ok := value.(map[string]interface{}) 8356 if !ok { 8357 return fmt.Errorf("unexpected JSON type %v", value) 8358 } 8359 8360 var sv *types.GrpcRouteAction 8361 if *v == nil { 8362 sv = &types.GrpcRouteAction{} 8363 } else { 8364 sv = *v 8365 } 8366 8367 for key, value := range shape { 8368 switch key { 8369 case "weightedTargets": 8370 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 8371 return err 8372 } 8373 8374 default: 8375 _, _ = key, value 8376 8377 } 8378 } 8379 *v = sv 8380 return nil 8381} 8382 8383func awsRestjson1_deserializeDocumentGrpcRouteMatch(v **types.GrpcRouteMatch, value interface{}) error { 8384 if v == nil { 8385 return fmt.Errorf("unexpected nil of type %T", v) 8386 } 8387 if value == nil { 8388 return nil 8389 } 8390 8391 shape, ok := value.(map[string]interface{}) 8392 if !ok { 8393 return fmt.Errorf("unexpected JSON type %v", value) 8394 } 8395 8396 var sv *types.GrpcRouteMatch 8397 if *v == nil { 8398 sv = &types.GrpcRouteMatch{} 8399 } else { 8400 sv = *v 8401 } 8402 8403 for key, value := range shape { 8404 switch key { 8405 case "metadata": 8406 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadataList(&sv.Metadata, value); err != nil { 8407 return err 8408 } 8409 8410 case "methodName": 8411 if value != nil { 8412 jtv, ok := value.(string) 8413 if !ok { 8414 return fmt.Errorf("expected MethodName to be of type string, got %T instead", value) 8415 } 8416 sv.MethodName = ptr.String(jtv) 8417 } 8418 8419 case "serviceName": 8420 if value != nil { 8421 jtv, ok := value.(string) 8422 if !ok { 8423 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 8424 } 8425 sv.ServiceName = ptr.String(jtv) 8426 } 8427 8428 default: 8429 _, _ = key, value 8430 8431 } 8432 } 8433 *v = sv 8434 return nil 8435} 8436 8437func awsRestjson1_deserializeDocumentGrpcRouteMetadata(v **types.GrpcRouteMetadata, value interface{}) error { 8438 if v == nil { 8439 return fmt.Errorf("unexpected nil of type %T", v) 8440 } 8441 if value == nil { 8442 return nil 8443 } 8444 8445 shape, ok := value.(map[string]interface{}) 8446 if !ok { 8447 return fmt.Errorf("unexpected JSON type %v", value) 8448 } 8449 8450 var sv *types.GrpcRouteMetadata 8451 if *v == nil { 8452 sv = &types.GrpcRouteMetadata{} 8453 } else { 8454 sv = *v 8455 } 8456 8457 for key, value := range shape { 8458 switch key { 8459 case "invert": 8460 if value != nil { 8461 jtv, ok := value.(bool) 8462 if !ok { 8463 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8464 } 8465 sv.Invert = ptr.Bool(jtv) 8466 } 8467 8468 case "match": 8469 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadataMatchMethod(&sv.Match, value); err != nil { 8470 return err 8471 } 8472 8473 case "name": 8474 if value != nil { 8475 jtv, ok := value.(string) 8476 if !ok { 8477 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 8478 } 8479 sv.Name = ptr.String(jtv) 8480 } 8481 8482 default: 8483 _, _ = key, value 8484 8485 } 8486 } 8487 *v = sv 8488 return nil 8489} 8490 8491func awsRestjson1_deserializeDocumentGrpcRouteMetadataList(v *[]types.GrpcRouteMetadata, value interface{}) error { 8492 if v == nil { 8493 return fmt.Errorf("unexpected nil of type %T", v) 8494 } 8495 if value == nil { 8496 return nil 8497 } 8498 8499 shape, ok := value.([]interface{}) 8500 if !ok { 8501 return fmt.Errorf("unexpected JSON type %v", value) 8502 } 8503 8504 var cv []types.GrpcRouteMetadata 8505 if *v == nil { 8506 cv = []types.GrpcRouteMetadata{} 8507 } else { 8508 cv = *v 8509 } 8510 8511 for _, value := range shape { 8512 var col types.GrpcRouteMetadata 8513 destAddr := &col 8514 if err := awsRestjson1_deserializeDocumentGrpcRouteMetadata(&destAddr, value); err != nil { 8515 return err 8516 } 8517 col = *destAddr 8518 cv = append(cv, col) 8519 8520 } 8521 *v = cv 8522 return nil 8523} 8524 8525func awsRestjson1_deserializeDocumentGrpcRouteMetadataMatchMethod(v *types.GrpcRouteMetadataMatchMethod, value interface{}) error { 8526 if v == nil { 8527 return fmt.Errorf("unexpected nil of type %T", v) 8528 } 8529 if value == nil { 8530 return nil 8531 } 8532 8533 shape, ok := value.(map[string]interface{}) 8534 if !ok { 8535 return fmt.Errorf("unexpected JSON type %v", value) 8536 } 8537 8538 var uv types.GrpcRouteMetadataMatchMethod 8539loop: 8540 for key, value := range shape { 8541 if value == nil { 8542 continue 8543 } 8544 switch key { 8545 case "exact": 8546 var mv string 8547 if value != nil { 8548 jtv, ok := value.(string) 8549 if !ok { 8550 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8551 } 8552 mv = jtv 8553 } 8554 uv = &types.GrpcRouteMetadataMatchMethodMemberExact{Value: mv} 8555 break loop 8556 8557 case "prefix": 8558 var mv string 8559 if value != nil { 8560 jtv, ok := value.(string) 8561 if !ok { 8562 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8563 } 8564 mv = jtv 8565 } 8566 uv = &types.GrpcRouteMetadataMatchMethodMemberPrefix{Value: mv} 8567 break loop 8568 8569 case "range": 8570 var mv types.MatchRange 8571 destAddr := &mv 8572 if err := awsRestjson1_deserializeDocumentMatchRange(&destAddr, value); err != nil { 8573 return err 8574 } 8575 mv = *destAddr 8576 uv = &types.GrpcRouteMetadataMatchMethodMemberRange{Value: mv} 8577 break loop 8578 8579 case "regex": 8580 var mv string 8581 if value != nil { 8582 jtv, ok := value.(string) 8583 if !ok { 8584 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8585 } 8586 mv = jtv 8587 } 8588 uv = &types.GrpcRouteMetadataMatchMethodMemberRegex{Value: mv} 8589 break loop 8590 8591 case "suffix": 8592 var mv string 8593 if value != nil { 8594 jtv, ok := value.(string) 8595 if !ok { 8596 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8597 } 8598 mv = jtv 8599 } 8600 uv = &types.GrpcRouteMetadataMatchMethodMemberSuffix{Value: mv} 8601 break loop 8602 8603 default: 8604 uv = &types.UnknownUnionMember{Tag: key} 8605 break loop 8606 8607 } 8608 } 8609 *v = uv 8610 return nil 8611} 8612 8613func awsRestjson1_deserializeDocumentGrpcTimeout(v **types.GrpcTimeout, value interface{}) error { 8614 if v == nil { 8615 return fmt.Errorf("unexpected nil of type %T", v) 8616 } 8617 if value == nil { 8618 return nil 8619 } 8620 8621 shape, ok := value.(map[string]interface{}) 8622 if !ok { 8623 return fmt.Errorf("unexpected JSON type %v", value) 8624 } 8625 8626 var sv *types.GrpcTimeout 8627 if *v == nil { 8628 sv = &types.GrpcTimeout{} 8629 } else { 8630 sv = *v 8631 } 8632 8633 for key, value := range shape { 8634 switch key { 8635 case "idle": 8636 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 8637 return err 8638 } 8639 8640 case "perRequest": 8641 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRequest, value); err != nil { 8642 return err 8643 } 8644 8645 default: 8646 _, _ = key, value 8647 8648 } 8649 } 8650 *v = sv 8651 return nil 8652} 8653 8654func awsRestjson1_deserializeDocumentHeaderMatchMethod(v *types.HeaderMatchMethod, value interface{}) error { 8655 if v == nil { 8656 return fmt.Errorf("unexpected nil of type %T", v) 8657 } 8658 if value == nil { 8659 return nil 8660 } 8661 8662 shape, ok := value.(map[string]interface{}) 8663 if !ok { 8664 return fmt.Errorf("unexpected JSON type %v", value) 8665 } 8666 8667 var uv types.HeaderMatchMethod 8668loop: 8669 for key, value := range shape { 8670 if value == nil { 8671 continue 8672 } 8673 switch key { 8674 case "exact": 8675 var mv string 8676 if value != nil { 8677 jtv, ok := value.(string) 8678 if !ok { 8679 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8680 } 8681 mv = jtv 8682 } 8683 uv = &types.HeaderMatchMethodMemberExact{Value: mv} 8684 break loop 8685 8686 case "prefix": 8687 var mv string 8688 if value != nil { 8689 jtv, ok := value.(string) 8690 if !ok { 8691 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8692 } 8693 mv = jtv 8694 } 8695 uv = &types.HeaderMatchMethodMemberPrefix{Value: mv} 8696 break loop 8697 8698 case "range": 8699 var mv types.MatchRange 8700 destAddr := &mv 8701 if err := awsRestjson1_deserializeDocumentMatchRange(&destAddr, value); err != nil { 8702 return err 8703 } 8704 mv = *destAddr 8705 uv = &types.HeaderMatchMethodMemberRange{Value: mv} 8706 break loop 8707 8708 case "regex": 8709 var mv string 8710 if value != nil { 8711 jtv, ok := value.(string) 8712 if !ok { 8713 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8714 } 8715 mv = jtv 8716 } 8717 uv = &types.HeaderMatchMethodMemberRegex{Value: mv} 8718 break loop 8719 8720 case "suffix": 8721 var mv string 8722 if value != nil { 8723 jtv, ok := value.(string) 8724 if !ok { 8725 return fmt.Errorf("expected HeaderMatch to be of type string, got %T instead", value) 8726 } 8727 mv = jtv 8728 } 8729 uv = &types.HeaderMatchMethodMemberSuffix{Value: mv} 8730 break loop 8731 8732 default: 8733 uv = &types.UnknownUnionMember{Tag: key} 8734 break loop 8735 8736 } 8737 } 8738 *v = uv 8739 return nil 8740} 8741 8742func awsRestjson1_deserializeDocumentHealthCheckPolicy(v **types.HealthCheckPolicy, value interface{}) error { 8743 if v == nil { 8744 return fmt.Errorf("unexpected nil of type %T", v) 8745 } 8746 if value == nil { 8747 return nil 8748 } 8749 8750 shape, ok := value.(map[string]interface{}) 8751 if !ok { 8752 return fmt.Errorf("unexpected JSON type %v", value) 8753 } 8754 8755 var sv *types.HealthCheckPolicy 8756 if *v == nil { 8757 sv = &types.HealthCheckPolicy{} 8758 } else { 8759 sv = *v 8760 } 8761 8762 for key, value := range shape { 8763 switch key { 8764 case "healthyThreshold": 8765 if value != nil { 8766 jtv, ok := value.(json.Number) 8767 if !ok { 8768 return fmt.Errorf("expected HealthCheckThreshold to be json.Number, got %T instead", value) 8769 } 8770 i64, err := jtv.Int64() 8771 if err != nil { 8772 return err 8773 } 8774 sv.HealthyThreshold = int32(i64) 8775 } 8776 8777 case "intervalMillis": 8778 if value != nil { 8779 jtv, ok := value.(json.Number) 8780 if !ok { 8781 return fmt.Errorf("expected HealthCheckIntervalMillis to be json.Number, got %T instead", value) 8782 } 8783 i64, err := jtv.Int64() 8784 if err != nil { 8785 return err 8786 } 8787 sv.IntervalMillis = ptr.Int64(i64) 8788 } 8789 8790 case "path": 8791 if value != nil { 8792 jtv, ok := value.(string) 8793 if !ok { 8794 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8795 } 8796 sv.Path = ptr.String(jtv) 8797 } 8798 8799 case "port": 8800 if value != nil { 8801 jtv, ok := value.(json.Number) 8802 if !ok { 8803 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8804 } 8805 i64, err := jtv.Int64() 8806 if err != nil { 8807 return err 8808 } 8809 sv.Port = int32(i64) 8810 } 8811 8812 case "protocol": 8813 if value != nil { 8814 jtv, ok := value.(string) 8815 if !ok { 8816 return fmt.Errorf("expected PortProtocol to be of type string, got %T instead", value) 8817 } 8818 sv.Protocol = types.PortProtocol(jtv) 8819 } 8820 8821 case "timeoutMillis": 8822 if value != nil { 8823 jtv, ok := value.(json.Number) 8824 if !ok { 8825 return fmt.Errorf("expected HealthCheckTimeoutMillis to be json.Number, got %T instead", value) 8826 } 8827 i64, err := jtv.Int64() 8828 if err != nil { 8829 return err 8830 } 8831 sv.TimeoutMillis = ptr.Int64(i64) 8832 } 8833 8834 case "unhealthyThreshold": 8835 if value != nil { 8836 jtv, ok := value.(json.Number) 8837 if !ok { 8838 return fmt.Errorf("expected HealthCheckThreshold to be json.Number, got %T instead", value) 8839 } 8840 i64, err := jtv.Int64() 8841 if err != nil { 8842 return err 8843 } 8844 sv.UnhealthyThreshold = int32(i64) 8845 } 8846 8847 default: 8848 _, _ = key, value 8849 8850 } 8851 } 8852 *v = sv 8853 return nil 8854} 8855 8856func awsRestjson1_deserializeDocumentHttpGatewayRoute(v **types.HttpGatewayRoute, value interface{}) error { 8857 if v == nil { 8858 return fmt.Errorf("unexpected nil of type %T", v) 8859 } 8860 if value == nil { 8861 return nil 8862 } 8863 8864 shape, ok := value.(map[string]interface{}) 8865 if !ok { 8866 return fmt.Errorf("unexpected JSON type %v", value) 8867 } 8868 8869 var sv *types.HttpGatewayRoute 8870 if *v == nil { 8871 sv = &types.HttpGatewayRoute{} 8872 } else { 8873 sv = *v 8874 } 8875 8876 for key, value := range shape { 8877 switch key { 8878 case "action": 8879 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteAction(&sv.Action, value); err != nil { 8880 return err 8881 } 8882 8883 case "match": 8884 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteMatch(&sv.Match, value); err != nil { 8885 return err 8886 } 8887 8888 default: 8889 _, _ = key, value 8890 8891 } 8892 } 8893 *v = sv 8894 return nil 8895} 8896 8897func awsRestjson1_deserializeDocumentHttpGatewayRouteAction(v **types.HttpGatewayRouteAction, value interface{}) error { 8898 if v == nil { 8899 return fmt.Errorf("unexpected nil of type %T", v) 8900 } 8901 if value == nil { 8902 return nil 8903 } 8904 8905 shape, ok := value.(map[string]interface{}) 8906 if !ok { 8907 return fmt.Errorf("unexpected JSON type %v", value) 8908 } 8909 8910 var sv *types.HttpGatewayRouteAction 8911 if *v == nil { 8912 sv = &types.HttpGatewayRouteAction{} 8913 } else { 8914 sv = *v 8915 } 8916 8917 for key, value := range shape { 8918 switch key { 8919 case "rewrite": 8920 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteRewrite(&sv.Rewrite, value); err != nil { 8921 return err 8922 } 8923 8924 case "target": 8925 if err := awsRestjson1_deserializeDocumentGatewayRouteTarget(&sv.Target, value); err != nil { 8926 return err 8927 } 8928 8929 default: 8930 _, _ = key, value 8931 8932 } 8933 } 8934 *v = sv 8935 return nil 8936} 8937 8938func awsRestjson1_deserializeDocumentHttpGatewayRouteHeader(v **types.HttpGatewayRouteHeader, value interface{}) error { 8939 if v == nil { 8940 return fmt.Errorf("unexpected nil of type %T", v) 8941 } 8942 if value == nil { 8943 return nil 8944 } 8945 8946 shape, ok := value.(map[string]interface{}) 8947 if !ok { 8948 return fmt.Errorf("unexpected JSON type %v", value) 8949 } 8950 8951 var sv *types.HttpGatewayRouteHeader 8952 if *v == nil { 8953 sv = &types.HttpGatewayRouteHeader{} 8954 } else { 8955 sv = *v 8956 } 8957 8958 for key, value := range shape { 8959 switch key { 8960 case "invert": 8961 if value != nil { 8962 jtv, ok := value.(bool) 8963 if !ok { 8964 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8965 } 8966 sv.Invert = ptr.Bool(jtv) 8967 } 8968 8969 case "match": 8970 if err := awsRestjson1_deserializeDocumentHeaderMatchMethod(&sv.Match, value); err != nil { 8971 return err 8972 } 8973 8974 case "name": 8975 if value != nil { 8976 jtv, ok := value.(string) 8977 if !ok { 8978 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 8979 } 8980 sv.Name = ptr.String(jtv) 8981 } 8982 8983 default: 8984 _, _ = key, value 8985 8986 } 8987 } 8988 *v = sv 8989 return nil 8990} 8991 8992func awsRestjson1_deserializeDocumentHttpGatewayRouteHeaders(v *[]types.HttpGatewayRouteHeader, value interface{}) error { 8993 if v == nil { 8994 return fmt.Errorf("unexpected nil of type %T", v) 8995 } 8996 if value == nil { 8997 return nil 8998 } 8999 9000 shape, ok := value.([]interface{}) 9001 if !ok { 9002 return fmt.Errorf("unexpected JSON type %v", value) 9003 } 9004 9005 var cv []types.HttpGatewayRouteHeader 9006 if *v == nil { 9007 cv = []types.HttpGatewayRouteHeader{} 9008 } else { 9009 cv = *v 9010 } 9011 9012 for _, value := range shape { 9013 var col types.HttpGatewayRouteHeader 9014 destAddr := &col 9015 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteHeader(&destAddr, value); err != nil { 9016 return err 9017 } 9018 col = *destAddr 9019 cv = append(cv, col) 9020 9021 } 9022 *v = cv 9023 return nil 9024} 9025 9026func awsRestjson1_deserializeDocumentHttpGatewayRouteMatch(v **types.HttpGatewayRouteMatch, value interface{}) error { 9027 if v == nil { 9028 return fmt.Errorf("unexpected nil of type %T", v) 9029 } 9030 if value == nil { 9031 return nil 9032 } 9033 9034 shape, ok := value.(map[string]interface{}) 9035 if !ok { 9036 return fmt.Errorf("unexpected JSON type %v", value) 9037 } 9038 9039 var sv *types.HttpGatewayRouteMatch 9040 if *v == nil { 9041 sv = &types.HttpGatewayRouteMatch{} 9042 } else { 9043 sv = *v 9044 } 9045 9046 for key, value := range shape { 9047 switch key { 9048 case "headers": 9049 if err := awsRestjson1_deserializeDocumentHttpGatewayRouteHeaders(&sv.Headers, value); err != nil { 9050 return err 9051 } 9052 9053 case "hostname": 9054 if err := awsRestjson1_deserializeDocumentGatewayRouteHostnameMatch(&sv.Hostname, value); err != nil { 9055 return err 9056 } 9057 9058 case "method": 9059 if value != nil { 9060 jtv, ok := value.(string) 9061 if !ok { 9062 return fmt.Errorf("expected HttpMethod to be of type string, got %T instead", value) 9063 } 9064 sv.Method = types.HttpMethod(jtv) 9065 } 9066 9067 case "path": 9068 if err := awsRestjson1_deserializeDocumentHttpPathMatch(&sv.Path, value); err != nil { 9069 return err 9070 } 9071 9072 case "prefix": 9073 if value != nil { 9074 jtv, ok := value.(string) 9075 if !ok { 9076 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9077 } 9078 sv.Prefix = ptr.String(jtv) 9079 } 9080 9081 case "queryParameters": 9082 if err := awsRestjson1_deserializeDocumentHttpQueryParameters(&sv.QueryParameters, value); err != nil { 9083 return err 9084 } 9085 9086 default: 9087 _, _ = key, value 9088 9089 } 9090 } 9091 *v = sv 9092 return nil 9093} 9094 9095func awsRestjson1_deserializeDocumentHttpGatewayRoutePathRewrite(v **types.HttpGatewayRoutePathRewrite, value interface{}) error { 9096 if v == nil { 9097 return fmt.Errorf("unexpected nil of type %T", v) 9098 } 9099 if value == nil { 9100 return nil 9101 } 9102 9103 shape, ok := value.(map[string]interface{}) 9104 if !ok { 9105 return fmt.Errorf("unexpected JSON type %v", value) 9106 } 9107 9108 var sv *types.HttpGatewayRoutePathRewrite 9109 if *v == nil { 9110 sv = &types.HttpGatewayRoutePathRewrite{} 9111 } else { 9112 sv = *v 9113 } 9114 9115 for key, value := range shape { 9116 switch key { 9117 case "exact": 9118 if value != nil { 9119 jtv, ok := value.(string) 9120 if !ok { 9121 return fmt.Errorf("expected HttpPathExact to be of type string, got %T instead", value) 9122 } 9123 sv.Exact = ptr.String(jtv) 9124 } 9125 9126 default: 9127 _, _ = key, value 9128 9129 } 9130 } 9131 *v = sv 9132 return nil 9133} 9134 9135func awsRestjson1_deserializeDocumentHttpGatewayRoutePrefixRewrite(v **types.HttpGatewayRoutePrefixRewrite, value interface{}) error { 9136 if v == nil { 9137 return fmt.Errorf("unexpected nil of type %T", v) 9138 } 9139 if value == nil { 9140 return nil 9141 } 9142 9143 shape, ok := value.(map[string]interface{}) 9144 if !ok { 9145 return fmt.Errorf("unexpected JSON type %v", value) 9146 } 9147 9148 var sv *types.HttpGatewayRoutePrefixRewrite 9149 if *v == nil { 9150 sv = &types.HttpGatewayRoutePrefixRewrite{} 9151 } else { 9152 sv = *v 9153 } 9154 9155 for key, value := range shape { 9156 switch key { 9157 case "defaultPrefix": 9158 if value != nil { 9159 jtv, ok := value.(string) 9160 if !ok { 9161 return fmt.Errorf("expected DefaultGatewayRouteRewrite to be of type string, got %T instead", value) 9162 } 9163 sv.DefaultPrefix = types.DefaultGatewayRouteRewrite(jtv) 9164 } 9165 9166 case "value": 9167 if value != nil { 9168 jtv, ok := value.(string) 9169 if !ok { 9170 return fmt.Errorf("expected HttpGatewayRoutePrefix to be of type string, got %T instead", value) 9171 } 9172 sv.Value = ptr.String(jtv) 9173 } 9174 9175 default: 9176 _, _ = key, value 9177 9178 } 9179 } 9180 *v = sv 9181 return nil 9182} 9183 9184func awsRestjson1_deserializeDocumentHttpGatewayRouteRewrite(v **types.HttpGatewayRouteRewrite, value interface{}) error { 9185 if v == nil { 9186 return fmt.Errorf("unexpected nil of type %T", v) 9187 } 9188 if value == nil { 9189 return nil 9190 } 9191 9192 shape, ok := value.(map[string]interface{}) 9193 if !ok { 9194 return fmt.Errorf("unexpected JSON type %v", value) 9195 } 9196 9197 var sv *types.HttpGatewayRouteRewrite 9198 if *v == nil { 9199 sv = &types.HttpGatewayRouteRewrite{} 9200 } else { 9201 sv = *v 9202 } 9203 9204 for key, value := range shape { 9205 switch key { 9206 case "hostname": 9207 if err := awsRestjson1_deserializeDocumentGatewayRouteHostnameRewrite(&sv.Hostname, value); err != nil { 9208 return err 9209 } 9210 9211 case "path": 9212 if err := awsRestjson1_deserializeDocumentHttpGatewayRoutePathRewrite(&sv.Path, value); err != nil { 9213 return err 9214 } 9215 9216 case "prefix": 9217 if err := awsRestjson1_deserializeDocumentHttpGatewayRoutePrefixRewrite(&sv.Prefix, value); err != nil { 9218 return err 9219 } 9220 9221 default: 9222 _, _ = key, value 9223 9224 } 9225 } 9226 *v = sv 9227 return nil 9228} 9229 9230func awsRestjson1_deserializeDocumentHttpPathMatch(v **types.HttpPathMatch, value interface{}) error { 9231 if v == nil { 9232 return fmt.Errorf("unexpected nil of type %T", v) 9233 } 9234 if value == nil { 9235 return nil 9236 } 9237 9238 shape, ok := value.(map[string]interface{}) 9239 if !ok { 9240 return fmt.Errorf("unexpected JSON type %v", value) 9241 } 9242 9243 var sv *types.HttpPathMatch 9244 if *v == nil { 9245 sv = &types.HttpPathMatch{} 9246 } else { 9247 sv = *v 9248 } 9249 9250 for key, value := range shape { 9251 switch key { 9252 case "exact": 9253 if value != nil { 9254 jtv, ok := value.(string) 9255 if !ok { 9256 return fmt.Errorf("expected HttpPathExact to be of type string, got %T instead", value) 9257 } 9258 sv.Exact = ptr.String(jtv) 9259 } 9260 9261 case "regex": 9262 if value != nil { 9263 jtv, ok := value.(string) 9264 if !ok { 9265 return fmt.Errorf("expected HttpPathRegex to be of type string, got %T instead", value) 9266 } 9267 sv.Regex = ptr.String(jtv) 9268 } 9269 9270 default: 9271 _, _ = key, value 9272 9273 } 9274 } 9275 *v = sv 9276 return nil 9277} 9278 9279func awsRestjson1_deserializeDocumentHttpQueryParameter(v **types.HttpQueryParameter, value interface{}) error { 9280 if v == nil { 9281 return fmt.Errorf("unexpected nil of type %T", v) 9282 } 9283 if value == nil { 9284 return nil 9285 } 9286 9287 shape, ok := value.(map[string]interface{}) 9288 if !ok { 9289 return fmt.Errorf("unexpected JSON type %v", value) 9290 } 9291 9292 var sv *types.HttpQueryParameter 9293 if *v == nil { 9294 sv = &types.HttpQueryParameter{} 9295 } else { 9296 sv = *v 9297 } 9298 9299 for key, value := range shape { 9300 switch key { 9301 case "match": 9302 if err := awsRestjson1_deserializeDocumentQueryParameterMatch(&sv.Match, value); err != nil { 9303 return err 9304 } 9305 9306 case "name": 9307 if value != nil { 9308 jtv, ok := value.(string) 9309 if !ok { 9310 return fmt.Errorf("expected QueryParameterName to be of type string, got %T instead", value) 9311 } 9312 sv.Name = ptr.String(jtv) 9313 } 9314 9315 default: 9316 _, _ = key, value 9317 9318 } 9319 } 9320 *v = sv 9321 return nil 9322} 9323 9324func awsRestjson1_deserializeDocumentHttpQueryParameters(v *[]types.HttpQueryParameter, value interface{}) error { 9325 if v == nil { 9326 return fmt.Errorf("unexpected nil of type %T", v) 9327 } 9328 if value == nil { 9329 return nil 9330 } 9331 9332 shape, ok := value.([]interface{}) 9333 if !ok { 9334 return fmt.Errorf("unexpected JSON type %v", value) 9335 } 9336 9337 var cv []types.HttpQueryParameter 9338 if *v == nil { 9339 cv = []types.HttpQueryParameter{} 9340 } else { 9341 cv = *v 9342 } 9343 9344 for _, value := range shape { 9345 var col types.HttpQueryParameter 9346 destAddr := &col 9347 if err := awsRestjson1_deserializeDocumentHttpQueryParameter(&destAddr, value); err != nil { 9348 return err 9349 } 9350 col = *destAddr 9351 cv = append(cv, col) 9352 9353 } 9354 *v = cv 9355 return nil 9356} 9357 9358func awsRestjson1_deserializeDocumentHttpRetryPolicy(v **types.HttpRetryPolicy, value interface{}) error { 9359 if v == nil { 9360 return fmt.Errorf("unexpected nil of type %T", v) 9361 } 9362 if value == nil { 9363 return nil 9364 } 9365 9366 shape, ok := value.(map[string]interface{}) 9367 if !ok { 9368 return fmt.Errorf("unexpected JSON type %v", value) 9369 } 9370 9371 var sv *types.HttpRetryPolicy 9372 if *v == nil { 9373 sv = &types.HttpRetryPolicy{} 9374 } else { 9375 sv = *v 9376 } 9377 9378 for key, value := range shape { 9379 switch key { 9380 case "httpRetryEvents": 9381 if err := awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(&sv.HttpRetryEvents, value); err != nil { 9382 return err 9383 } 9384 9385 case "maxRetries": 9386 if value != nil { 9387 jtv, ok := value.(json.Number) 9388 if !ok { 9389 return fmt.Errorf("expected MaxRetries to be json.Number, got %T instead", value) 9390 } 9391 i64, err := jtv.Int64() 9392 if err != nil { 9393 return err 9394 } 9395 sv.MaxRetries = ptr.Int64(i64) 9396 } 9397 9398 case "perRetryTimeout": 9399 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRetryTimeout, value); err != nil { 9400 return err 9401 } 9402 9403 case "tcpRetryEvents": 9404 if err := awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(&sv.TcpRetryEvents, value); err != nil { 9405 return err 9406 } 9407 9408 default: 9409 _, _ = key, value 9410 9411 } 9412 } 9413 *v = sv 9414 return nil 9415} 9416 9417func awsRestjson1_deserializeDocumentHttpRetryPolicyEvents(v *[]string, value interface{}) error { 9418 if v == nil { 9419 return fmt.Errorf("unexpected nil of type %T", v) 9420 } 9421 if value == nil { 9422 return nil 9423 } 9424 9425 shape, ok := value.([]interface{}) 9426 if !ok { 9427 return fmt.Errorf("unexpected JSON type %v", value) 9428 } 9429 9430 var cv []string 9431 if *v == nil { 9432 cv = []string{} 9433 } else { 9434 cv = *v 9435 } 9436 9437 for _, value := range shape { 9438 var col string 9439 if value != nil { 9440 jtv, ok := value.(string) 9441 if !ok { 9442 return fmt.Errorf("expected HttpRetryPolicyEvent to be of type string, got %T instead", value) 9443 } 9444 col = jtv 9445 } 9446 cv = append(cv, col) 9447 9448 } 9449 *v = cv 9450 return nil 9451} 9452 9453func awsRestjson1_deserializeDocumentHttpRoute(v **types.HttpRoute, value interface{}) error { 9454 if v == nil { 9455 return fmt.Errorf("unexpected nil of type %T", v) 9456 } 9457 if value == nil { 9458 return nil 9459 } 9460 9461 shape, ok := value.(map[string]interface{}) 9462 if !ok { 9463 return fmt.Errorf("unexpected JSON type %v", value) 9464 } 9465 9466 var sv *types.HttpRoute 9467 if *v == nil { 9468 sv = &types.HttpRoute{} 9469 } else { 9470 sv = *v 9471 } 9472 9473 for key, value := range shape { 9474 switch key { 9475 case "action": 9476 if err := awsRestjson1_deserializeDocumentHttpRouteAction(&sv.Action, value); err != nil { 9477 return err 9478 } 9479 9480 case "match": 9481 if err := awsRestjson1_deserializeDocumentHttpRouteMatch(&sv.Match, value); err != nil { 9482 return err 9483 } 9484 9485 case "retryPolicy": 9486 if err := awsRestjson1_deserializeDocumentHttpRetryPolicy(&sv.RetryPolicy, value); err != nil { 9487 return err 9488 } 9489 9490 case "timeout": 9491 if err := awsRestjson1_deserializeDocumentHttpTimeout(&sv.Timeout, value); err != nil { 9492 return err 9493 } 9494 9495 default: 9496 _, _ = key, value 9497 9498 } 9499 } 9500 *v = sv 9501 return nil 9502} 9503 9504func awsRestjson1_deserializeDocumentHttpRouteAction(v **types.HttpRouteAction, value interface{}) error { 9505 if v == nil { 9506 return fmt.Errorf("unexpected nil of type %T", v) 9507 } 9508 if value == nil { 9509 return nil 9510 } 9511 9512 shape, ok := value.(map[string]interface{}) 9513 if !ok { 9514 return fmt.Errorf("unexpected JSON type %v", value) 9515 } 9516 9517 var sv *types.HttpRouteAction 9518 if *v == nil { 9519 sv = &types.HttpRouteAction{} 9520 } else { 9521 sv = *v 9522 } 9523 9524 for key, value := range shape { 9525 switch key { 9526 case "weightedTargets": 9527 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 9528 return err 9529 } 9530 9531 default: 9532 _, _ = key, value 9533 9534 } 9535 } 9536 *v = sv 9537 return nil 9538} 9539 9540func awsRestjson1_deserializeDocumentHttpRouteHeader(v **types.HttpRouteHeader, value interface{}) error { 9541 if v == nil { 9542 return fmt.Errorf("unexpected nil of type %T", v) 9543 } 9544 if value == nil { 9545 return nil 9546 } 9547 9548 shape, ok := value.(map[string]interface{}) 9549 if !ok { 9550 return fmt.Errorf("unexpected JSON type %v", value) 9551 } 9552 9553 var sv *types.HttpRouteHeader 9554 if *v == nil { 9555 sv = &types.HttpRouteHeader{} 9556 } else { 9557 sv = *v 9558 } 9559 9560 for key, value := range shape { 9561 switch key { 9562 case "invert": 9563 if value != nil { 9564 jtv, ok := value.(bool) 9565 if !ok { 9566 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9567 } 9568 sv.Invert = ptr.Bool(jtv) 9569 } 9570 9571 case "match": 9572 if err := awsRestjson1_deserializeDocumentHeaderMatchMethod(&sv.Match, value); err != nil { 9573 return err 9574 } 9575 9576 case "name": 9577 if value != nil { 9578 jtv, ok := value.(string) 9579 if !ok { 9580 return fmt.Errorf("expected HeaderName to be of type string, got %T instead", value) 9581 } 9582 sv.Name = ptr.String(jtv) 9583 } 9584 9585 default: 9586 _, _ = key, value 9587 9588 } 9589 } 9590 *v = sv 9591 return nil 9592} 9593 9594func awsRestjson1_deserializeDocumentHttpRouteHeaders(v *[]types.HttpRouteHeader, value interface{}) error { 9595 if v == nil { 9596 return fmt.Errorf("unexpected nil of type %T", v) 9597 } 9598 if value == nil { 9599 return nil 9600 } 9601 9602 shape, ok := value.([]interface{}) 9603 if !ok { 9604 return fmt.Errorf("unexpected JSON type %v", value) 9605 } 9606 9607 var cv []types.HttpRouteHeader 9608 if *v == nil { 9609 cv = []types.HttpRouteHeader{} 9610 } else { 9611 cv = *v 9612 } 9613 9614 for _, value := range shape { 9615 var col types.HttpRouteHeader 9616 destAddr := &col 9617 if err := awsRestjson1_deserializeDocumentHttpRouteHeader(&destAddr, value); err != nil { 9618 return err 9619 } 9620 col = *destAddr 9621 cv = append(cv, col) 9622 9623 } 9624 *v = cv 9625 return nil 9626} 9627 9628func awsRestjson1_deserializeDocumentHttpRouteMatch(v **types.HttpRouteMatch, value interface{}) error { 9629 if v == nil { 9630 return fmt.Errorf("unexpected nil of type %T", v) 9631 } 9632 if value == nil { 9633 return nil 9634 } 9635 9636 shape, ok := value.(map[string]interface{}) 9637 if !ok { 9638 return fmt.Errorf("unexpected JSON type %v", value) 9639 } 9640 9641 var sv *types.HttpRouteMatch 9642 if *v == nil { 9643 sv = &types.HttpRouteMatch{} 9644 } else { 9645 sv = *v 9646 } 9647 9648 for key, value := range shape { 9649 switch key { 9650 case "headers": 9651 if err := awsRestjson1_deserializeDocumentHttpRouteHeaders(&sv.Headers, value); err != nil { 9652 return err 9653 } 9654 9655 case "method": 9656 if value != nil { 9657 jtv, ok := value.(string) 9658 if !ok { 9659 return fmt.Errorf("expected HttpMethod to be of type string, got %T instead", value) 9660 } 9661 sv.Method = types.HttpMethod(jtv) 9662 } 9663 9664 case "path": 9665 if err := awsRestjson1_deserializeDocumentHttpPathMatch(&sv.Path, value); err != nil { 9666 return err 9667 } 9668 9669 case "prefix": 9670 if value != nil { 9671 jtv, ok := value.(string) 9672 if !ok { 9673 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9674 } 9675 sv.Prefix = ptr.String(jtv) 9676 } 9677 9678 case "queryParameters": 9679 if err := awsRestjson1_deserializeDocumentHttpQueryParameters(&sv.QueryParameters, value); err != nil { 9680 return err 9681 } 9682 9683 case "scheme": 9684 if value != nil { 9685 jtv, ok := value.(string) 9686 if !ok { 9687 return fmt.Errorf("expected HttpScheme to be of type string, got %T instead", value) 9688 } 9689 sv.Scheme = types.HttpScheme(jtv) 9690 } 9691 9692 default: 9693 _, _ = key, value 9694 9695 } 9696 } 9697 *v = sv 9698 return nil 9699} 9700 9701func awsRestjson1_deserializeDocumentHttpTimeout(v **types.HttpTimeout, value interface{}) error { 9702 if v == nil { 9703 return fmt.Errorf("unexpected nil of type %T", v) 9704 } 9705 if value == nil { 9706 return nil 9707 } 9708 9709 shape, ok := value.(map[string]interface{}) 9710 if !ok { 9711 return fmt.Errorf("unexpected JSON type %v", value) 9712 } 9713 9714 var sv *types.HttpTimeout 9715 if *v == nil { 9716 sv = &types.HttpTimeout{} 9717 } else { 9718 sv = *v 9719 } 9720 9721 for key, value := range shape { 9722 switch key { 9723 case "idle": 9724 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 9725 return err 9726 } 9727 9728 case "perRequest": 9729 if err := awsRestjson1_deserializeDocumentDuration(&sv.PerRequest, value); err != nil { 9730 return err 9731 } 9732 9733 default: 9734 _, _ = key, value 9735 9736 } 9737 } 9738 *v = sv 9739 return nil 9740} 9741 9742func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 9743 if v == nil { 9744 return fmt.Errorf("unexpected nil of type %T", v) 9745 } 9746 if value == nil { 9747 return nil 9748 } 9749 9750 shape, ok := value.(map[string]interface{}) 9751 if !ok { 9752 return fmt.Errorf("unexpected JSON type %v", value) 9753 } 9754 9755 var sv *types.InternalServerErrorException 9756 if *v == nil { 9757 sv = &types.InternalServerErrorException{} 9758 } else { 9759 sv = *v 9760 } 9761 9762 for key, value := range shape { 9763 switch key { 9764 case "message": 9765 if value != nil { 9766 jtv, ok := value.(string) 9767 if !ok { 9768 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9769 } 9770 sv.Message = ptr.String(jtv) 9771 } 9772 9773 default: 9774 _, _ = key, value 9775 9776 } 9777 } 9778 *v = sv 9779 return nil 9780} 9781 9782func awsRestjson1_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 9783 if v == nil { 9784 return fmt.Errorf("unexpected nil of type %T", v) 9785 } 9786 if value == nil { 9787 return nil 9788 } 9789 9790 shape, ok := value.(map[string]interface{}) 9791 if !ok { 9792 return fmt.Errorf("unexpected JSON type %v", value) 9793 } 9794 9795 var sv *types.LimitExceededException 9796 if *v == nil { 9797 sv = &types.LimitExceededException{} 9798 } else { 9799 sv = *v 9800 } 9801 9802 for key, value := range shape { 9803 switch key { 9804 case "message": 9805 if value != nil { 9806 jtv, ok := value.(string) 9807 if !ok { 9808 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9809 } 9810 sv.Message = ptr.String(jtv) 9811 } 9812 9813 default: 9814 _, _ = key, value 9815 9816 } 9817 } 9818 *v = sv 9819 return nil 9820} 9821 9822func awsRestjson1_deserializeDocumentListener(v **types.Listener, value interface{}) error { 9823 if v == nil { 9824 return fmt.Errorf("unexpected nil of type %T", v) 9825 } 9826 if value == nil { 9827 return nil 9828 } 9829 9830 shape, ok := value.(map[string]interface{}) 9831 if !ok { 9832 return fmt.Errorf("unexpected JSON type %v", value) 9833 } 9834 9835 var sv *types.Listener 9836 if *v == nil { 9837 sv = &types.Listener{} 9838 } else { 9839 sv = *v 9840 } 9841 9842 for key, value := range shape { 9843 switch key { 9844 case "connectionPool": 9845 if err := awsRestjson1_deserializeDocumentVirtualNodeConnectionPool(&sv.ConnectionPool, value); err != nil { 9846 return err 9847 } 9848 9849 case "healthCheck": 9850 if err := awsRestjson1_deserializeDocumentHealthCheckPolicy(&sv.HealthCheck, value); err != nil { 9851 return err 9852 } 9853 9854 case "outlierDetection": 9855 if err := awsRestjson1_deserializeDocumentOutlierDetection(&sv.OutlierDetection, value); err != nil { 9856 return err 9857 } 9858 9859 case "portMapping": 9860 if err := awsRestjson1_deserializeDocumentPortMapping(&sv.PortMapping, value); err != nil { 9861 return err 9862 } 9863 9864 case "timeout": 9865 if err := awsRestjson1_deserializeDocumentListenerTimeout(&sv.Timeout, value); err != nil { 9866 return err 9867 } 9868 9869 case "tls": 9870 if err := awsRestjson1_deserializeDocumentListenerTls(&sv.Tls, value); err != nil { 9871 return err 9872 } 9873 9874 default: 9875 _, _ = key, value 9876 9877 } 9878 } 9879 *v = sv 9880 return nil 9881} 9882 9883func awsRestjson1_deserializeDocumentListeners(v *[]types.Listener, value interface{}) error { 9884 if v == nil { 9885 return fmt.Errorf("unexpected nil of type %T", v) 9886 } 9887 if value == nil { 9888 return nil 9889 } 9890 9891 shape, ok := value.([]interface{}) 9892 if !ok { 9893 return fmt.Errorf("unexpected JSON type %v", value) 9894 } 9895 9896 var cv []types.Listener 9897 if *v == nil { 9898 cv = []types.Listener{} 9899 } else { 9900 cv = *v 9901 } 9902 9903 for _, value := range shape { 9904 var col types.Listener 9905 destAddr := &col 9906 if err := awsRestjson1_deserializeDocumentListener(&destAddr, value); err != nil { 9907 return err 9908 } 9909 col = *destAddr 9910 cv = append(cv, col) 9911 9912 } 9913 *v = cv 9914 return nil 9915} 9916 9917func awsRestjson1_deserializeDocumentListenerTimeout(v *types.ListenerTimeout, value interface{}) error { 9918 if v == nil { 9919 return fmt.Errorf("unexpected nil of type %T", v) 9920 } 9921 if value == nil { 9922 return nil 9923 } 9924 9925 shape, ok := value.(map[string]interface{}) 9926 if !ok { 9927 return fmt.Errorf("unexpected JSON type %v", value) 9928 } 9929 9930 var uv types.ListenerTimeout 9931loop: 9932 for key, value := range shape { 9933 if value == nil { 9934 continue 9935 } 9936 switch key { 9937 case "grpc": 9938 var mv types.GrpcTimeout 9939 destAddr := &mv 9940 if err := awsRestjson1_deserializeDocumentGrpcTimeout(&destAddr, value); err != nil { 9941 return err 9942 } 9943 mv = *destAddr 9944 uv = &types.ListenerTimeoutMemberGrpc{Value: mv} 9945 break loop 9946 9947 case "http": 9948 var mv types.HttpTimeout 9949 destAddr := &mv 9950 if err := awsRestjson1_deserializeDocumentHttpTimeout(&destAddr, value); err != nil { 9951 return err 9952 } 9953 mv = *destAddr 9954 uv = &types.ListenerTimeoutMemberHttp{Value: mv} 9955 break loop 9956 9957 case "http2": 9958 var mv types.HttpTimeout 9959 destAddr := &mv 9960 if err := awsRestjson1_deserializeDocumentHttpTimeout(&destAddr, value); err != nil { 9961 return err 9962 } 9963 mv = *destAddr 9964 uv = &types.ListenerTimeoutMemberHttp2{Value: mv} 9965 break loop 9966 9967 case "tcp": 9968 var mv types.TcpTimeout 9969 destAddr := &mv 9970 if err := awsRestjson1_deserializeDocumentTcpTimeout(&destAddr, value); err != nil { 9971 return err 9972 } 9973 mv = *destAddr 9974 uv = &types.ListenerTimeoutMemberTcp{Value: mv} 9975 break loop 9976 9977 default: 9978 uv = &types.UnknownUnionMember{Tag: key} 9979 break loop 9980 9981 } 9982 } 9983 *v = uv 9984 return nil 9985} 9986 9987func awsRestjson1_deserializeDocumentListenerTls(v **types.ListenerTls, value interface{}) error { 9988 if v == nil { 9989 return fmt.Errorf("unexpected nil of type %T", v) 9990 } 9991 if value == nil { 9992 return nil 9993 } 9994 9995 shape, ok := value.(map[string]interface{}) 9996 if !ok { 9997 return fmt.Errorf("unexpected JSON type %v", value) 9998 } 9999 10000 var sv *types.ListenerTls 10001 if *v == nil { 10002 sv = &types.ListenerTls{} 10003 } else { 10004 sv = *v 10005 } 10006 10007 for key, value := range shape { 10008 switch key { 10009 case "certificate": 10010 if err := awsRestjson1_deserializeDocumentListenerTlsCertificate(&sv.Certificate, value); err != nil { 10011 return err 10012 } 10013 10014 case "mode": 10015 if value != nil { 10016 jtv, ok := value.(string) 10017 if !ok { 10018 return fmt.Errorf("expected ListenerTlsMode to be of type string, got %T instead", value) 10019 } 10020 sv.Mode = types.ListenerTlsMode(jtv) 10021 } 10022 10023 case "validation": 10024 if err := awsRestjson1_deserializeDocumentListenerTlsValidationContext(&sv.Validation, value); err != nil { 10025 return err 10026 } 10027 10028 default: 10029 _, _ = key, value 10030 10031 } 10032 } 10033 *v = sv 10034 return nil 10035} 10036 10037func awsRestjson1_deserializeDocumentListenerTlsAcmCertificate(v **types.ListenerTlsAcmCertificate, value interface{}) error { 10038 if v == nil { 10039 return fmt.Errorf("unexpected nil of type %T", v) 10040 } 10041 if value == nil { 10042 return nil 10043 } 10044 10045 shape, ok := value.(map[string]interface{}) 10046 if !ok { 10047 return fmt.Errorf("unexpected JSON type %v", value) 10048 } 10049 10050 var sv *types.ListenerTlsAcmCertificate 10051 if *v == nil { 10052 sv = &types.ListenerTlsAcmCertificate{} 10053 } else { 10054 sv = *v 10055 } 10056 10057 for key, value := range shape { 10058 switch key { 10059 case "certificateArn": 10060 if value != nil { 10061 jtv, ok := value.(string) 10062 if !ok { 10063 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10064 } 10065 sv.CertificateArn = ptr.String(jtv) 10066 } 10067 10068 default: 10069 _, _ = key, value 10070 10071 } 10072 } 10073 *v = sv 10074 return nil 10075} 10076 10077func awsRestjson1_deserializeDocumentListenerTlsCertificate(v *types.ListenerTlsCertificate, value interface{}) error { 10078 if v == nil { 10079 return fmt.Errorf("unexpected nil of type %T", v) 10080 } 10081 if value == nil { 10082 return nil 10083 } 10084 10085 shape, ok := value.(map[string]interface{}) 10086 if !ok { 10087 return fmt.Errorf("unexpected JSON type %v", value) 10088 } 10089 10090 var uv types.ListenerTlsCertificate 10091loop: 10092 for key, value := range shape { 10093 if value == nil { 10094 continue 10095 } 10096 switch key { 10097 case "acm": 10098 var mv types.ListenerTlsAcmCertificate 10099 destAddr := &mv 10100 if err := awsRestjson1_deserializeDocumentListenerTlsAcmCertificate(&destAddr, value); err != nil { 10101 return err 10102 } 10103 mv = *destAddr 10104 uv = &types.ListenerTlsCertificateMemberAcm{Value: mv} 10105 break loop 10106 10107 case "file": 10108 var mv types.ListenerTlsFileCertificate 10109 destAddr := &mv 10110 if err := awsRestjson1_deserializeDocumentListenerTlsFileCertificate(&destAddr, value); err != nil { 10111 return err 10112 } 10113 mv = *destAddr 10114 uv = &types.ListenerTlsCertificateMemberFile{Value: mv} 10115 break loop 10116 10117 case "sds": 10118 var mv types.ListenerTlsSdsCertificate 10119 destAddr := &mv 10120 if err := awsRestjson1_deserializeDocumentListenerTlsSdsCertificate(&destAddr, value); err != nil { 10121 return err 10122 } 10123 mv = *destAddr 10124 uv = &types.ListenerTlsCertificateMemberSds{Value: mv} 10125 break loop 10126 10127 default: 10128 uv = &types.UnknownUnionMember{Tag: key} 10129 break loop 10130 10131 } 10132 } 10133 *v = uv 10134 return nil 10135} 10136 10137func awsRestjson1_deserializeDocumentListenerTlsFileCertificate(v **types.ListenerTlsFileCertificate, value interface{}) error { 10138 if v == nil { 10139 return fmt.Errorf("unexpected nil of type %T", v) 10140 } 10141 if value == nil { 10142 return nil 10143 } 10144 10145 shape, ok := value.(map[string]interface{}) 10146 if !ok { 10147 return fmt.Errorf("unexpected JSON type %v", value) 10148 } 10149 10150 var sv *types.ListenerTlsFileCertificate 10151 if *v == nil { 10152 sv = &types.ListenerTlsFileCertificate{} 10153 } else { 10154 sv = *v 10155 } 10156 10157 for key, value := range shape { 10158 switch key { 10159 case "certificateChain": 10160 if value != nil { 10161 jtv, ok := value.(string) 10162 if !ok { 10163 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 10164 } 10165 sv.CertificateChain = ptr.String(jtv) 10166 } 10167 10168 case "privateKey": 10169 if value != nil { 10170 jtv, ok := value.(string) 10171 if !ok { 10172 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 10173 } 10174 sv.PrivateKey = ptr.String(jtv) 10175 } 10176 10177 default: 10178 _, _ = key, value 10179 10180 } 10181 } 10182 *v = sv 10183 return nil 10184} 10185 10186func awsRestjson1_deserializeDocumentListenerTlsSdsCertificate(v **types.ListenerTlsSdsCertificate, value interface{}) error { 10187 if v == nil { 10188 return fmt.Errorf("unexpected nil of type %T", v) 10189 } 10190 if value == nil { 10191 return nil 10192 } 10193 10194 shape, ok := value.(map[string]interface{}) 10195 if !ok { 10196 return fmt.Errorf("unexpected JSON type %v", value) 10197 } 10198 10199 var sv *types.ListenerTlsSdsCertificate 10200 if *v == nil { 10201 sv = &types.ListenerTlsSdsCertificate{} 10202 } else { 10203 sv = *v 10204 } 10205 10206 for key, value := range shape { 10207 switch key { 10208 case "secretName": 10209 if value != nil { 10210 jtv, ok := value.(string) 10211 if !ok { 10212 return fmt.Errorf("expected SdsSecretName to be of type string, got %T instead", value) 10213 } 10214 sv.SecretName = ptr.String(jtv) 10215 } 10216 10217 default: 10218 _, _ = key, value 10219 10220 } 10221 } 10222 *v = sv 10223 return nil 10224} 10225 10226func awsRestjson1_deserializeDocumentListenerTlsValidationContext(v **types.ListenerTlsValidationContext, value interface{}) error { 10227 if v == nil { 10228 return fmt.Errorf("unexpected nil of type %T", v) 10229 } 10230 if value == nil { 10231 return nil 10232 } 10233 10234 shape, ok := value.(map[string]interface{}) 10235 if !ok { 10236 return fmt.Errorf("unexpected JSON type %v", value) 10237 } 10238 10239 var sv *types.ListenerTlsValidationContext 10240 if *v == nil { 10241 sv = &types.ListenerTlsValidationContext{} 10242 } else { 10243 sv = *v 10244 } 10245 10246 for key, value := range shape { 10247 switch key { 10248 case "subjectAlternativeNames": 10249 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 10250 return err 10251 } 10252 10253 case "trust": 10254 if err := awsRestjson1_deserializeDocumentListenerTlsValidationContextTrust(&sv.Trust, value); err != nil { 10255 return err 10256 } 10257 10258 default: 10259 _, _ = key, value 10260 10261 } 10262 } 10263 *v = sv 10264 return nil 10265} 10266 10267func awsRestjson1_deserializeDocumentListenerTlsValidationContextTrust(v *types.ListenerTlsValidationContextTrust, value interface{}) error { 10268 if v == nil { 10269 return fmt.Errorf("unexpected nil of type %T", v) 10270 } 10271 if value == nil { 10272 return nil 10273 } 10274 10275 shape, ok := value.(map[string]interface{}) 10276 if !ok { 10277 return fmt.Errorf("unexpected JSON type %v", value) 10278 } 10279 10280 var uv types.ListenerTlsValidationContextTrust 10281loop: 10282 for key, value := range shape { 10283 if value == nil { 10284 continue 10285 } 10286 switch key { 10287 case "file": 10288 var mv types.TlsValidationContextFileTrust 10289 destAddr := &mv 10290 if err := awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(&destAddr, value); err != nil { 10291 return err 10292 } 10293 mv = *destAddr 10294 uv = &types.ListenerTlsValidationContextTrustMemberFile{Value: mv} 10295 break loop 10296 10297 case "sds": 10298 var mv types.TlsValidationContextSdsTrust 10299 destAddr := &mv 10300 if err := awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(&destAddr, value); err != nil { 10301 return err 10302 } 10303 mv = *destAddr 10304 uv = &types.ListenerTlsValidationContextTrustMemberSds{Value: mv} 10305 break loop 10306 10307 default: 10308 uv = &types.UnknownUnionMember{Tag: key} 10309 break loop 10310 10311 } 10312 } 10313 *v = uv 10314 return nil 10315} 10316 10317func awsRestjson1_deserializeDocumentLogging(v **types.Logging, value interface{}) error { 10318 if v == nil { 10319 return fmt.Errorf("unexpected nil of type %T", v) 10320 } 10321 if value == nil { 10322 return nil 10323 } 10324 10325 shape, ok := value.(map[string]interface{}) 10326 if !ok { 10327 return fmt.Errorf("unexpected JSON type %v", value) 10328 } 10329 10330 var sv *types.Logging 10331 if *v == nil { 10332 sv = &types.Logging{} 10333 } else { 10334 sv = *v 10335 } 10336 10337 for key, value := range shape { 10338 switch key { 10339 case "accessLog": 10340 if err := awsRestjson1_deserializeDocumentAccessLog(&sv.AccessLog, value); err != nil { 10341 return err 10342 } 10343 10344 default: 10345 _, _ = key, value 10346 10347 } 10348 } 10349 *v = sv 10350 return nil 10351} 10352 10353func awsRestjson1_deserializeDocumentMatchRange(v **types.MatchRange, value interface{}) error { 10354 if v == nil { 10355 return fmt.Errorf("unexpected nil of type %T", v) 10356 } 10357 if value == nil { 10358 return nil 10359 } 10360 10361 shape, ok := value.(map[string]interface{}) 10362 if !ok { 10363 return fmt.Errorf("unexpected JSON type %v", value) 10364 } 10365 10366 var sv *types.MatchRange 10367 if *v == nil { 10368 sv = &types.MatchRange{} 10369 } else { 10370 sv = *v 10371 } 10372 10373 for key, value := range shape { 10374 switch key { 10375 case "end": 10376 if value != nil { 10377 jtv, ok := value.(json.Number) 10378 if !ok { 10379 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10380 } 10381 i64, err := jtv.Int64() 10382 if err != nil { 10383 return err 10384 } 10385 sv.End = ptr.Int64(i64) 10386 } 10387 10388 case "start": 10389 if value != nil { 10390 jtv, ok := value.(json.Number) 10391 if !ok { 10392 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10393 } 10394 i64, err := jtv.Int64() 10395 if err != nil { 10396 return err 10397 } 10398 sv.Start = ptr.Int64(i64) 10399 } 10400 10401 default: 10402 _, _ = key, value 10403 10404 } 10405 } 10406 *v = sv 10407 return nil 10408} 10409 10410func awsRestjson1_deserializeDocumentMeshData(v **types.MeshData, value interface{}) error { 10411 if v == nil { 10412 return fmt.Errorf("unexpected nil of type %T", v) 10413 } 10414 if value == nil { 10415 return nil 10416 } 10417 10418 shape, ok := value.(map[string]interface{}) 10419 if !ok { 10420 return fmt.Errorf("unexpected JSON type %v", value) 10421 } 10422 10423 var sv *types.MeshData 10424 if *v == nil { 10425 sv = &types.MeshData{} 10426 } else { 10427 sv = *v 10428 } 10429 10430 for key, value := range shape { 10431 switch key { 10432 case "meshName": 10433 if value != nil { 10434 jtv, ok := value.(string) 10435 if !ok { 10436 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10437 } 10438 sv.MeshName = ptr.String(jtv) 10439 } 10440 10441 case "metadata": 10442 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 10443 return err 10444 } 10445 10446 case "spec": 10447 if err := awsRestjson1_deserializeDocumentMeshSpec(&sv.Spec, value); err != nil { 10448 return err 10449 } 10450 10451 case "status": 10452 if err := awsRestjson1_deserializeDocumentMeshStatus(&sv.Status, value); err != nil { 10453 return err 10454 } 10455 10456 default: 10457 _, _ = key, value 10458 10459 } 10460 } 10461 *v = sv 10462 return nil 10463} 10464 10465func awsRestjson1_deserializeDocumentMeshList(v *[]types.MeshRef, value interface{}) error { 10466 if v == nil { 10467 return fmt.Errorf("unexpected nil of type %T", v) 10468 } 10469 if value == nil { 10470 return nil 10471 } 10472 10473 shape, ok := value.([]interface{}) 10474 if !ok { 10475 return fmt.Errorf("unexpected JSON type %v", value) 10476 } 10477 10478 var cv []types.MeshRef 10479 if *v == nil { 10480 cv = []types.MeshRef{} 10481 } else { 10482 cv = *v 10483 } 10484 10485 for _, value := range shape { 10486 var col types.MeshRef 10487 destAddr := &col 10488 if err := awsRestjson1_deserializeDocumentMeshRef(&destAddr, value); err != nil { 10489 return err 10490 } 10491 col = *destAddr 10492 cv = append(cv, col) 10493 10494 } 10495 *v = cv 10496 return nil 10497} 10498 10499func awsRestjson1_deserializeDocumentMeshRef(v **types.MeshRef, value interface{}) error { 10500 if v == nil { 10501 return fmt.Errorf("unexpected nil of type %T", v) 10502 } 10503 if value == nil { 10504 return nil 10505 } 10506 10507 shape, ok := value.(map[string]interface{}) 10508 if !ok { 10509 return fmt.Errorf("unexpected JSON type %v", value) 10510 } 10511 10512 var sv *types.MeshRef 10513 if *v == nil { 10514 sv = &types.MeshRef{} 10515 } else { 10516 sv = *v 10517 } 10518 10519 for key, value := range shape { 10520 switch key { 10521 case "arn": 10522 if value != nil { 10523 jtv, ok := value.(string) 10524 if !ok { 10525 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10526 } 10527 sv.Arn = ptr.String(jtv) 10528 } 10529 10530 case "createdAt": 10531 if value != nil { 10532 switch jtv := value.(type) { 10533 case json.Number: 10534 f64, err := jtv.Float64() 10535 if err != nil { 10536 return err 10537 } 10538 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10539 10540 default: 10541 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10542 10543 } 10544 } 10545 10546 case "lastUpdatedAt": 10547 if value != nil { 10548 switch jtv := value.(type) { 10549 case json.Number: 10550 f64, err := jtv.Float64() 10551 if err != nil { 10552 return err 10553 } 10554 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10555 10556 default: 10557 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 10558 10559 } 10560 } 10561 10562 case "meshName": 10563 if value != nil { 10564 jtv, ok := value.(string) 10565 if !ok { 10566 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 10567 } 10568 sv.MeshName = ptr.String(jtv) 10569 } 10570 10571 case "meshOwner": 10572 if value != nil { 10573 jtv, ok := value.(string) 10574 if !ok { 10575 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10576 } 10577 sv.MeshOwner = ptr.String(jtv) 10578 } 10579 10580 case "resourceOwner": 10581 if value != nil { 10582 jtv, ok := value.(string) 10583 if !ok { 10584 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10585 } 10586 sv.ResourceOwner = ptr.String(jtv) 10587 } 10588 10589 case "version": 10590 if value != nil { 10591 jtv, ok := value.(json.Number) 10592 if !ok { 10593 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 10594 } 10595 i64, err := jtv.Int64() 10596 if err != nil { 10597 return err 10598 } 10599 sv.Version = ptr.Int64(i64) 10600 } 10601 10602 default: 10603 _, _ = key, value 10604 10605 } 10606 } 10607 *v = sv 10608 return nil 10609} 10610 10611func awsRestjson1_deserializeDocumentMeshSpec(v **types.MeshSpec, value interface{}) error { 10612 if v == nil { 10613 return fmt.Errorf("unexpected nil of type %T", v) 10614 } 10615 if value == nil { 10616 return nil 10617 } 10618 10619 shape, ok := value.(map[string]interface{}) 10620 if !ok { 10621 return fmt.Errorf("unexpected JSON type %v", value) 10622 } 10623 10624 var sv *types.MeshSpec 10625 if *v == nil { 10626 sv = &types.MeshSpec{} 10627 } else { 10628 sv = *v 10629 } 10630 10631 for key, value := range shape { 10632 switch key { 10633 case "egressFilter": 10634 if err := awsRestjson1_deserializeDocumentEgressFilter(&sv.EgressFilter, value); err != nil { 10635 return err 10636 } 10637 10638 default: 10639 _, _ = key, value 10640 10641 } 10642 } 10643 *v = sv 10644 return nil 10645} 10646 10647func awsRestjson1_deserializeDocumentMeshStatus(v **types.MeshStatus, value interface{}) error { 10648 if v == nil { 10649 return fmt.Errorf("unexpected nil of type %T", v) 10650 } 10651 if value == nil { 10652 return nil 10653 } 10654 10655 shape, ok := value.(map[string]interface{}) 10656 if !ok { 10657 return fmt.Errorf("unexpected JSON type %v", value) 10658 } 10659 10660 var sv *types.MeshStatus 10661 if *v == nil { 10662 sv = &types.MeshStatus{} 10663 } else { 10664 sv = *v 10665 } 10666 10667 for key, value := range shape { 10668 switch key { 10669 case "status": 10670 if value != nil { 10671 jtv, ok := value.(string) 10672 if !ok { 10673 return fmt.Errorf("expected MeshStatusCode to be of type string, got %T instead", value) 10674 } 10675 sv.Status = types.MeshStatusCode(jtv) 10676 } 10677 10678 default: 10679 _, _ = key, value 10680 10681 } 10682 } 10683 *v = sv 10684 return nil 10685} 10686 10687func awsRestjson1_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 10688 if v == nil { 10689 return fmt.Errorf("unexpected nil of type %T", v) 10690 } 10691 if value == nil { 10692 return nil 10693 } 10694 10695 shape, ok := value.(map[string]interface{}) 10696 if !ok { 10697 return fmt.Errorf("unexpected JSON type %v", value) 10698 } 10699 10700 var sv *types.NotFoundException 10701 if *v == nil { 10702 sv = &types.NotFoundException{} 10703 } else { 10704 sv = *v 10705 } 10706 10707 for key, value := range shape { 10708 switch key { 10709 case "message": 10710 if value != nil { 10711 jtv, ok := value.(string) 10712 if !ok { 10713 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10714 } 10715 sv.Message = ptr.String(jtv) 10716 } 10717 10718 default: 10719 _, _ = key, value 10720 10721 } 10722 } 10723 *v = sv 10724 return nil 10725} 10726 10727func awsRestjson1_deserializeDocumentOutlierDetection(v **types.OutlierDetection, value interface{}) error { 10728 if v == nil { 10729 return fmt.Errorf("unexpected nil of type %T", v) 10730 } 10731 if value == nil { 10732 return nil 10733 } 10734 10735 shape, ok := value.(map[string]interface{}) 10736 if !ok { 10737 return fmt.Errorf("unexpected JSON type %v", value) 10738 } 10739 10740 var sv *types.OutlierDetection 10741 if *v == nil { 10742 sv = &types.OutlierDetection{} 10743 } else { 10744 sv = *v 10745 } 10746 10747 for key, value := range shape { 10748 switch key { 10749 case "baseEjectionDuration": 10750 if err := awsRestjson1_deserializeDocumentDuration(&sv.BaseEjectionDuration, value); err != nil { 10751 return err 10752 } 10753 10754 case "interval": 10755 if err := awsRestjson1_deserializeDocumentDuration(&sv.Interval, value); err != nil { 10756 return err 10757 } 10758 10759 case "maxEjectionPercent": 10760 if value != nil { 10761 jtv, ok := value.(json.Number) 10762 if !ok { 10763 return fmt.Errorf("expected OutlierDetectionMaxEjectionPercent to be json.Number, got %T instead", value) 10764 } 10765 i64, err := jtv.Int64() 10766 if err != nil { 10767 return err 10768 } 10769 sv.MaxEjectionPercent = ptr.Int32(int32(i64)) 10770 } 10771 10772 case "maxServerErrors": 10773 if value != nil { 10774 jtv, ok := value.(json.Number) 10775 if !ok { 10776 return fmt.Errorf("expected OutlierDetectionMaxServerErrors to be json.Number, got %T instead", value) 10777 } 10778 i64, err := jtv.Int64() 10779 if err != nil { 10780 return err 10781 } 10782 sv.MaxServerErrors = ptr.Int64(i64) 10783 } 10784 10785 default: 10786 _, _ = key, value 10787 10788 } 10789 } 10790 *v = sv 10791 return nil 10792} 10793 10794func awsRestjson1_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error { 10795 if v == nil { 10796 return fmt.Errorf("unexpected nil of type %T", v) 10797 } 10798 if value == nil { 10799 return nil 10800 } 10801 10802 shape, ok := value.(map[string]interface{}) 10803 if !ok { 10804 return fmt.Errorf("unexpected JSON type %v", value) 10805 } 10806 10807 var sv *types.PortMapping 10808 if *v == nil { 10809 sv = &types.PortMapping{} 10810 } else { 10811 sv = *v 10812 } 10813 10814 for key, value := range shape { 10815 switch key { 10816 case "port": 10817 if value != nil { 10818 jtv, ok := value.(json.Number) 10819 if !ok { 10820 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 10821 } 10822 i64, err := jtv.Int64() 10823 if err != nil { 10824 return err 10825 } 10826 sv.Port = int32(i64) 10827 } 10828 10829 case "protocol": 10830 if value != nil { 10831 jtv, ok := value.(string) 10832 if !ok { 10833 return fmt.Errorf("expected PortProtocol to be of type string, got %T instead", value) 10834 } 10835 sv.Protocol = types.PortProtocol(jtv) 10836 } 10837 10838 default: 10839 _, _ = key, value 10840 10841 } 10842 } 10843 *v = sv 10844 return nil 10845} 10846 10847func awsRestjson1_deserializeDocumentPortSet(v *[]int32, value interface{}) error { 10848 if v == nil { 10849 return fmt.Errorf("unexpected nil of type %T", v) 10850 } 10851 if value == nil { 10852 return nil 10853 } 10854 10855 shape, ok := value.([]interface{}) 10856 if !ok { 10857 return fmt.Errorf("unexpected JSON type %v", value) 10858 } 10859 10860 var cv []int32 10861 if *v == nil { 10862 cv = []int32{} 10863 } else { 10864 cv = *v 10865 } 10866 10867 for _, value := range shape { 10868 var col int32 10869 if value != nil { 10870 jtv, ok := value.(json.Number) 10871 if !ok { 10872 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 10873 } 10874 i64, err := jtv.Int64() 10875 if err != nil { 10876 return err 10877 } 10878 col = int32(i64) 10879 } 10880 cv = append(cv, col) 10881 10882 } 10883 *v = cv 10884 return nil 10885} 10886 10887func awsRestjson1_deserializeDocumentQueryParameterMatch(v **types.QueryParameterMatch, value interface{}) error { 10888 if v == nil { 10889 return fmt.Errorf("unexpected nil of type %T", v) 10890 } 10891 if value == nil { 10892 return nil 10893 } 10894 10895 shape, ok := value.(map[string]interface{}) 10896 if !ok { 10897 return fmt.Errorf("unexpected JSON type %v", value) 10898 } 10899 10900 var sv *types.QueryParameterMatch 10901 if *v == nil { 10902 sv = &types.QueryParameterMatch{} 10903 } else { 10904 sv = *v 10905 } 10906 10907 for key, value := range shape { 10908 switch key { 10909 case "exact": 10910 if value != nil { 10911 jtv, ok := value.(string) 10912 if !ok { 10913 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10914 } 10915 sv.Exact = ptr.String(jtv) 10916 } 10917 10918 default: 10919 _, _ = key, value 10920 10921 } 10922 } 10923 *v = sv 10924 return nil 10925} 10926 10927func awsRestjson1_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 10928 if v == nil { 10929 return fmt.Errorf("unexpected nil of type %T", v) 10930 } 10931 if value == nil { 10932 return nil 10933 } 10934 10935 shape, ok := value.(map[string]interface{}) 10936 if !ok { 10937 return fmt.Errorf("unexpected JSON type %v", value) 10938 } 10939 10940 var sv *types.ResourceInUseException 10941 if *v == nil { 10942 sv = &types.ResourceInUseException{} 10943 } else { 10944 sv = *v 10945 } 10946 10947 for key, value := range shape { 10948 switch key { 10949 case "message": 10950 if value != nil { 10951 jtv, ok := value.(string) 10952 if !ok { 10953 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10954 } 10955 sv.Message = ptr.String(jtv) 10956 } 10957 10958 default: 10959 _, _ = key, value 10960 10961 } 10962 } 10963 *v = sv 10964 return nil 10965} 10966 10967func awsRestjson1_deserializeDocumentResourceMetadata(v **types.ResourceMetadata, value interface{}) error { 10968 if v == nil { 10969 return fmt.Errorf("unexpected nil of type %T", v) 10970 } 10971 if value == nil { 10972 return nil 10973 } 10974 10975 shape, ok := value.(map[string]interface{}) 10976 if !ok { 10977 return fmt.Errorf("unexpected JSON type %v", value) 10978 } 10979 10980 var sv *types.ResourceMetadata 10981 if *v == nil { 10982 sv = &types.ResourceMetadata{} 10983 } else { 10984 sv = *v 10985 } 10986 10987 for key, value := range shape { 10988 switch key { 10989 case "arn": 10990 if value != nil { 10991 jtv, ok := value.(string) 10992 if !ok { 10993 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10994 } 10995 sv.Arn = ptr.String(jtv) 10996 } 10997 10998 case "createdAt": 10999 if value != nil { 11000 switch jtv := value.(type) { 11001 case json.Number: 11002 f64, err := jtv.Float64() 11003 if err != nil { 11004 return err 11005 } 11006 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11007 11008 default: 11009 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 11010 11011 } 11012 } 11013 11014 case "lastUpdatedAt": 11015 if value != nil { 11016 switch jtv := value.(type) { 11017 case json.Number: 11018 f64, err := jtv.Float64() 11019 if err != nil { 11020 return err 11021 } 11022 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11023 11024 default: 11025 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 11026 11027 } 11028 } 11029 11030 case "meshOwner": 11031 if value != nil { 11032 jtv, ok := value.(string) 11033 if !ok { 11034 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 11035 } 11036 sv.MeshOwner = ptr.String(jtv) 11037 } 11038 11039 case "resourceOwner": 11040 if value != nil { 11041 jtv, ok := value.(string) 11042 if !ok { 11043 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 11044 } 11045 sv.ResourceOwner = ptr.String(jtv) 11046 } 11047 11048 case "uid": 11049 if value != nil { 11050 jtv, ok := value.(string) 11051 if !ok { 11052 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11053 } 11054 sv.Uid = ptr.String(jtv) 11055 } 11056 11057 case "version": 11058 if value != nil { 11059 jtv, ok := value.(json.Number) 11060 if !ok { 11061 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 11062 } 11063 i64, err := jtv.Int64() 11064 if err != nil { 11065 return err 11066 } 11067 sv.Version = ptr.Int64(i64) 11068 } 11069 11070 default: 11071 _, _ = key, value 11072 11073 } 11074 } 11075 *v = sv 11076 return nil 11077} 11078 11079func awsRestjson1_deserializeDocumentRouteData(v **types.RouteData, value interface{}) error { 11080 if v == nil { 11081 return fmt.Errorf("unexpected nil of type %T", v) 11082 } 11083 if value == nil { 11084 return nil 11085 } 11086 11087 shape, ok := value.(map[string]interface{}) 11088 if !ok { 11089 return fmt.Errorf("unexpected JSON type %v", value) 11090 } 11091 11092 var sv *types.RouteData 11093 if *v == nil { 11094 sv = &types.RouteData{} 11095 } else { 11096 sv = *v 11097 } 11098 11099 for key, value := range shape { 11100 switch key { 11101 case "meshName": 11102 if value != nil { 11103 jtv, ok := value.(string) 11104 if !ok { 11105 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11106 } 11107 sv.MeshName = ptr.String(jtv) 11108 } 11109 11110 case "metadata": 11111 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 11112 return err 11113 } 11114 11115 case "routeName": 11116 if value != nil { 11117 jtv, ok := value.(string) 11118 if !ok { 11119 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11120 } 11121 sv.RouteName = ptr.String(jtv) 11122 } 11123 11124 case "spec": 11125 if err := awsRestjson1_deserializeDocumentRouteSpec(&sv.Spec, value); err != nil { 11126 return err 11127 } 11128 11129 case "status": 11130 if err := awsRestjson1_deserializeDocumentRouteStatus(&sv.Status, value); err != nil { 11131 return err 11132 } 11133 11134 case "virtualRouterName": 11135 if value != nil { 11136 jtv, ok := value.(string) 11137 if !ok { 11138 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11139 } 11140 sv.VirtualRouterName = ptr.String(jtv) 11141 } 11142 11143 default: 11144 _, _ = key, value 11145 11146 } 11147 } 11148 *v = sv 11149 return nil 11150} 11151 11152func awsRestjson1_deserializeDocumentRouteList(v *[]types.RouteRef, value interface{}) error { 11153 if v == nil { 11154 return fmt.Errorf("unexpected nil of type %T", v) 11155 } 11156 if value == nil { 11157 return nil 11158 } 11159 11160 shape, ok := value.([]interface{}) 11161 if !ok { 11162 return fmt.Errorf("unexpected JSON type %v", value) 11163 } 11164 11165 var cv []types.RouteRef 11166 if *v == nil { 11167 cv = []types.RouteRef{} 11168 } else { 11169 cv = *v 11170 } 11171 11172 for _, value := range shape { 11173 var col types.RouteRef 11174 destAddr := &col 11175 if err := awsRestjson1_deserializeDocumentRouteRef(&destAddr, value); err != nil { 11176 return err 11177 } 11178 col = *destAddr 11179 cv = append(cv, col) 11180 11181 } 11182 *v = cv 11183 return nil 11184} 11185 11186func awsRestjson1_deserializeDocumentRouteRef(v **types.RouteRef, value interface{}) error { 11187 if v == nil { 11188 return fmt.Errorf("unexpected nil of type %T", v) 11189 } 11190 if value == nil { 11191 return nil 11192 } 11193 11194 shape, ok := value.(map[string]interface{}) 11195 if !ok { 11196 return fmt.Errorf("unexpected JSON type %v", value) 11197 } 11198 11199 var sv *types.RouteRef 11200 if *v == nil { 11201 sv = &types.RouteRef{} 11202 } else { 11203 sv = *v 11204 } 11205 11206 for key, value := range shape { 11207 switch key { 11208 case "arn": 11209 if value != nil { 11210 jtv, ok := value.(string) 11211 if !ok { 11212 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 11213 } 11214 sv.Arn = ptr.String(jtv) 11215 } 11216 11217 case "createdAt": 11218 if value != nil { 11219 switch jtv := value.(type) { 11220 case json.Number: 11221 f64, err := jtv.Float64() 11222 if err != nil { 11223 return err 11224 } 11225 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11226 11227 default: 11228 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 11229 11230 } 11231 } 11232 11233 case "lastUpdatedAt": 11234 if value != nil { 11235 switch jtv := value.(type) { 11236 case json.Number: 11237 f64, err := jtv.Float64() 11238 if err != nil { 11239 return err 11240 } 11241 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11242 11243 default: 11244 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 11245 11246 } 11247 } 11248 11249 case "meshName": 11250 if value != nil { 11251 jtv, ok := value.(string) 11252 if !ok { 11253 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11254 } 11255 sv.MeshName = ptr.String(jtv) 11256 } 11257 11258 case "meshOwner": 11259 if value != nil { 11260 jtv, ok := value.(string) 11261 if !ok { 11262 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 11263 } 11264 sv.MeshOwner = ptr.String(jtv) 11265 } 11266 11267 case "resourceOwner": 11268 if value != nil { 11269 jtv, ok := value.(string) 11270 if !ok { 11271 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 11272 } 11273 sv.ResourceOwner = ptr.String(jtv) 11274 } 11275 11276 case "routeName": 11277 if value != nil { 11278 jtv, ok := value.(string) 11279 if !ok { 11280 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11281 } 11282 sv.RouteName = ptr.String(jtv) 11283 } 11284 11285 case "version": 11286 if value != nil { 11287 jtv, ok := value.(json.Number) 11288 if !ok { 11289 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 11290 } 11291 i64, err := jtv.Int64() 11292 if err != nil { 11293 return err 11294 } 11295 sv.Version = ptr.Int64(i64) 11296 } 11297 11298 case "virtualRouterName": 11299 if value != nil { 11300 jtv, ok := value.(string) 11301 if !ok { 11302 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 11303 } 11304 sv.VirtualRouterName = ptr.String(jtv) 11305 } 11306 11307 default: 11308 _, _ = key, value 11309 11310 } 11311 } 11312 *v = sv 11313 return nil 11314} 11315 11316func awsRestjson1_deserializeDocumentRouteSpec(v **types.RouteSpec, value interface{}) error { 11317 if v == nil { 11318 return fmt.Errorf("unexpected nil of type %T", v) 11319 } 11320 if value == nil { 11321 return nil 11322 } 11323 11324 shape, ok := value.(map[string]interface{}) 11325 if !ok { 11326 return fmt.Errorf("unexpected JSON type %v", value) 11327 } 11328 11329 var sv *types.RouteSpec 11330 if *v == nil { 11331 sv = &types.RouteSpec{} 11332 } else { 11333 sv = *v 11334 } 11335 11336 for key, value := range shape { 11337 switch key { 11338 case "grpcRoute": 11339 if err := awsRestjson1_deserializeDocumentGrpcRoute(&sv.GrpcRoute, value); err != nil { 11340 return err 11341 } 11342 11343 case "http2Route": 11344 if err := awsRestjson1_deserializeDocumentHttpRoute(&sv.Http2Route, value); err != nil { 11345 return err 11346 } 11347 11348 case "httpRoute": 11349 if err := awsRestjson1_deserializeDocumentHttpRoute(&sv.HttpRoute, value); err != nil { 11350 return err 11351 } 11352 11353 case "priority": 11354 if value != nil { 11355 jtv, ok := value.(json.Number) 11356 if !ok { 11357 return fmt.Errorf("expected RoutePriority to be json.Number, got %T instead", value) 11358 } 11359 i64, err := jtv.Int64() 11360 if err != nil { 11361 return err 11362 } 11363 sv.Priority = ptr.Int32(int32(i64)) 11364 } 11365 11366 case "tcpRoute": 11367 if err := awsRestjson1_deserializeDocumentTcpRoute(&sv.TcpRoute, value); err != nil { 11368 return err 11369 } 11370 11371 default: 11372 _, _ = key, value 11373 11374 } 11375 } 11376 *v = sv 11377 return nil 11378} 11379 11380func awsRestjson1_deserializeDocumentRouteStatus(v **types.RouteStatus, value interface{}) error { 11381 if v == nil { 11382 return fmt.Errorf("unexpected nil of type %T", v) 11383 } 11384 if value == nil { 11385 return nil 11386 } 11387 11388 shape, ok := value.(map[string]interface{}) 11389 if !ok { 11390 return fmt.Errorf("unexpected JSON type %v", value) 11391 } 11392 11393 var sv *types.RouteStatus 11394 if *v == nil { 11395 sv = &types.RouteStatus{} 11396 } else { 11397 sv = *v 11398 } 11399 11400 for key, value := range shape { 11401 switch key { 11402 case "status": 11403 if value != nil { 11404 jtv, ok := value.(string) 11405 if !ok { 11406 return fmt.Errorf("expected RouteStatusCode to be of type string, got %T instead", value) 11407 } 11408 sv.Status = types.RouteStatusCode(jtv) 11409 } 11410 11411 default: 11412 _, _ = key, value 11413 11414 } 11415 } 11416 *v = sv 11417 return nil 11418} 11419 11420func awsRestjson1_deserializeDocumentServiceDiscovery(v *types.ServiceDiscovery, value interface{}) error { 11421 if v == nil { 11422 return fmt.Errorf("unexpected nil of type %T", v) 11423 } 11424 if value == nil { 11425 return nil 11426 } 11427 11428 shape, ok := value.(map[string]interface{}) 11429 if !ok { 11430 return fmt.Errorf("unexpected JSON type %v", value) 11431 } 11432 11433 var uv types.ServiceDiscovery 11434loop: 11435 for key, value := range shape { 11436 if value == nil { 11437 continue 11438 } 11439 switch key { 11440 case "awsCloudMap": 11441 var mv types.AwsCloudMapServiceDiscovery 11442 destAddr := &mv 11443 if err := awsRestjson1_deserializeDocumentAwsCloudMapServiceDiscovery(&destAddr, value); err != nil { 11444 return err 11445 } 11446 mv = *destAddr 11447 uv = &types.ServiceDiscoveryMemberAwsCloudMap{Value: mv} 11448 break loop 11449 11450 case "dns": 11451 var mv types.DnsServiceDiscovery 11452 destAddr := &mv 11453 if err := awsRestjson1_deserializeDocumentDnsServiceDiscovery(&destAddr, value); err != nil { 11454 return err 11455 } 11456 mv = *destAddr 11457 uv = &types.ServiceDiscoveryMemberDns{Value: mv} 11458 break loop 11459 11460 default: 11461 uv = &types.UnknownUnionMember{Tag: key} 11462 break loop 11463 11464 } 11465 } 11466 *v = uv 11467 return nil 11468} 11469 11470func awsRestjson1_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { 11471 if v == nil { 11472 return fmt.Errorf("unexpected nil of type %T", v) 11473 } 11474 if value == nil { 11475 return nil 11476 } 11477 11478 shape, ok := value.(map[string]interface{}) 11479 if !ok { 11480 return fmt.Errorf("unexpected JSON type %v", value) 11481 } 11482 11483 var sv *types.ServiceUnavailableException 11484 if *v == nil { 11485 sv = &types.ServiceUnavailableException{} 11486 } else { 11487 sv = *v 11488 } 11489 11490 for key, value := range shape { 11491 switch key { 11492 case "message": 11493 if value != nil { 11494 jtv, ok := value.(string) 11495 if !ok { 11496 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11497 } 11498 sv.Message = ptr.String(jtv) 11499 } 11500 11501 default: 11502 _, _ = key, value 11503 11504 } 11505 } 11506 *v = sv 11507 return nil 11508} 11509 11510func awsRestjson1_deserializeDocumentSubjectAlternativeNameList(v *[]string, value interface{}) error { 11511 if v == nil { 11512 return fmt.Errorf("unexpected nil of type %T", v) 11513 } 11514 if value == nil { 11515 return nil 11516 } 11517 11518 shape, ok := value.([]interface{}) 11519 if !ok { 11520 return fmt.Errorf("unexpected JSON type %v", value) 11521 } 11522 11523 var cv []string 11524 if *v == nil { 11525 cv = []string{} 11526 } else { 11527 cv = *v 11528 } 11529 11530 for _, value := range shape { 11531 var col string 11532 if value != nil { 11533 jtv, ok := value.(string) 11534 if !ok { 11535 return fmt.Errorf("expected SubjectAlternativeName to be of type string, got %T instead", value) 11536 } 11537 col = jtv 11538 } 11539 cv = append(cv, col) 11540 11541 } 11542 *v = cv 11543 return nil 11544} 11545 11546func awsRestjson1_deserializeDocumentSubjectAlternativeNameMatchers(v **types.SubjectAlternativeNameMatchers, value interface{}) error { 11547 if v == nil { 11548 return fmt.Errorf("unexpected nil of type %T", v) 11549 } 11550 if value == nil { 11551 return nil 11552 } 11553 11554 shape, ok := value.(map[string]interface{}) 11555 if !ok { 11556 return fmt.Errorf("unexpected JSON type %v", value) 11557 } 11558 11559 var sv *types.SubjectAlternativeNameMatchers 11560 if *v == nil { 11561 sv = &types.SubjectAlternativeNameMatchers{} 11562 } else { 11563 sv = *v 11564 } 11565 11566 for key, value := range shape { 11567 switch key { 11568 case "exact": 11569 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNameList(&sv.Exact, value); err != nil { 11570 return err 11571 } 11572 11573 default: 11574 _, _ = key, value 11575 11576 } 11577 } 11578 *v = sv 11579 return nil 11580} 11581 11582func awsRestjson1_deserializeDocumentSubjectAlternativeNames(v **types.SubjectAlternativeNames, value interface{}) error { 11583 if v == nil { 11584 return fmt.Errorf("unexpected nil of type %T", v) 11585 } 11586 if value == nil { 11587 return nil 11588 } 11589 11590 shape, ok := value.(map[string]interface{}) 11591 if !ok { 11592 return fmt.Errorf("unexpected JSON type %v", value) 11593 } 11594 11595 var sv *types.SubjectAlternativeNames 11596 if *v == nil { 11597 sv = &types.SubjectAlternativeNames{} 11598 } else { 11599 sv = *v 11600 } 11601 11602 for key, value := range shape { 11603 switch key { 11604 case "match": 11605 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNameMatchers(&sv.Match, value); err != nil { 11606 return err 11607 } 11608 11609 default: 11610 _, _ = key, value 11611 11612 } 11613 } 11614 *v = sv 11615 return nil 11616} 11617 11618func awsRestjson1_deserializeDocumentTagList(v *[]types.TagRef, value interface{}) error { 11619 if v == nil { 11620 return fmt.Errorf("unexpected nil of type %T", v) 11621 } 11622 if value == nil { 11623 return nil 11624 } 11625 11626 shape, ok := value.([]interface{}) 11627 if !ok { 11628 return fmt.Errorf("unexpected JSON type %v", value) 11629 } 11630 11631 var cv []types.TagRef 11632 if *v == nil { 11633 cv = []types.TagRef{} 11634 } else { 11635 cv = *v 11636 } 11637 11638 for _, value := range shape { 11639 var col types.TagRef 11640 destAddr := &col 11641 if err := awsRestjson1_deserializeDocumentTagRef(&destAddr, value); err != nil { 11642 return err 11643 } 11644 col = *destAddr 11645 cv = append(cv, col) 11646 11647 } 11648 *v = cv 11649 return nil 11650} 11651 11652func awsRestjson1_deserializeDocumentTagRef(v **types.TagRef, value interface{}) error { 11653 if v == nil { 11654 return fmt.Errorf("unexpected nil of type %T", v) 11655 } 11656 if value == nil { 11657 return nil 11658 } 11659 11660 shape, ok := value.(map[string]interface{}) 11661 if !ok { 11662 return fmt.Errorf("unexpected JSON type %v", value) 11663 } 11664 11665 var sv *types.TagRef 11666 if *v == nil { 11667 sv = &types.TagRef{} 11668 } else { 11669 sv = *v 11670 } 11671 11672 for key, value := range shape { 11673 switch key { 11674 case "key": 11675 if value != nil { 11676 jtv, ok := value.(string) 11677 if !ok { 11678 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 11679 } 11680 sv.Key = ptr.String(jtv) 11681 } 11682 11683 case "value": 11684 if value != nil { 11685 jtv, ok := value.(string) 11686 if !ok { 11687 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 11688 } 11689 sv.Value = ptr.String(jtv) 11690 } 11691 11692 default: 11693 _, _ = key, value 11694 11695 } 11696 } 11697 *v = sv 11698 return nil 11699} 11700 11701func awsRestjson1_deserializeDocumentTcpRetryPolicyEvents(v *[]types.TcpRetryPolicyEvent, value interface{}) error { 11702 if v == nil { 11703 return fmt.Errorf("unexpected nil of type %T", v) 11704 } 11705 if value == nil { 11706 return nil 11707 } 11708 11709 shape, ok := value.([]interface{}) 11710 if !ok { 11711 return fmt.Errorf("unexpected JSON type %v", value) 11712 } 11713 11714 var cv []types.TcpRetryPolicyEvent 11715 if *v == nil { 11716 cv = []types.TcpRetryPolicyEvent{} 11717 } else { 11718 cv = *v 11719 } 11720 11721 for _, value := range shape { 11722 var col types.TcpRetryPolicyEvent 11723 if value != nil { 11724 jtv, ok := value.(string) 11725 if !ok { 11726 return fmt.Errorf("expected TcpRetryPolicyEvent to be of type string, got %T instead", value) 11727 } 11728 col = types.TcpRetryPolicyEvent(jtv) 11729 } 11730 cv = append(cv, col) 11731 11732 } 11733 *v = cv 11734 return nil 11735} 11736 11737func awsRestjson1_deserializeDocumentTcpRoute(v **types.TcpRoute, value interface{}) error { 11738 if v == nil { 11739 return fmt.Errorf("unexpected nil of type %T", v) 11740 } 11741 if value == nil { 11742 return nil 11743 } 11744 11745 shape, ok := value.(map[string]interface{}) 11746 if !ok { 11747 return fmt.Errorf("unexpected JSON type %v", value) 11748 } 11749 11750 var sv *types.TcpRoute 11751 if *v == nil { 11752 sv = &types.TcpRoute{} 11753 } else { 11754 sv = *v 11755 } 11756 11757 for key, value := range shape { 11758 switch key { 11759 case "action": 11760 if err := awsRestjson1_deserializeDocumentTcpRouteAction(&sv.Action, value); err != nil { 11761 return err 11762 } 11763 11764 case "timeout": 11765 if err := awsRestjson1_deserializeDocumentTcpTimeout(&sv.Timeout, value); err != nil { 11766 return err 11767 } 11768 11769 default: 11770 _, _ = key, value 11771 11772 } 11773 } 11774 *v = sv 11775 return nil 11776} 11777 11778func awsRestjson1_deserializeDocumentTcpRouteAction(v **types.TcpRouteAction, value interface{}) error { 11779 if v == nil { 11780 return fmt.Errorf("unexpected nil of type %T", v) 11781 } 11782 if value == nil { 11783 return nil 11784 } 11785 11786 shape, ok := value.(map[string]interface{}) 11787 if !ok { 11788 return fmt.Errorf("unexpected JSON type %v", value) 11789 } 11790 11791 var sv *types.TcpRouteAction 11792 if *v == nil { 11793 sv = &types.TcpRouteAction{} 11794 } else { 11795 sv = *v 11796 } 11797 11798 for key, value := range shape { 11799 switch key { 11800 case "weightedTargets": 11801 if err := awsRestjson1_deserializeDocumentWeightedTargets(&sv.WeightedTargets, value); err != nil { 11802 return err 11803 } 11804 11805 default: 11806 _, _ = key, value 11807 11808 } 11809 } 11810 *v = sv 11811 return nil 11812} 11813 11814func awsRestjson1_deserializeDocumentTcpTimeout(v **types.TcpTimeout, value interface{}) error { 11815 if v == nil { 11816 return fmt.Errorf("unexpected nil of type %T", v) 11817 } 11818 if value == nil { 11819 return nil 11820 } 11821 11822 shape, ok := value.(map[string]interface{}) 11823 if !ok { 11824 return fmt.Errorf("unexpected JSON type %v", value) 11825 } 11826 11827 var sv *types.TcpTimeout 11828 if *v == nil { 11829 sv = &types.TcpTimeout{} 11830 } else { 11831 sv = *v 11832 } 11833 11834 for key, value := range shape { 11835 switch key { 11836 case "idle": 11837 if err := awsRestjson1_deserializeDocumentDuration(&sv.Idle, value); err != nil { 11838 return err 11839 } 11840 11841 default: 11842 _, _ = key, value 11843 11844 } 11845 } 11846 *v = sv 11847 return nil 11848} 11849 11850func awsRestjson1_deserializeDocumentTlsValidationContext(v **types.TlsValidationContext, value interface{}) error { 11851 if v == nil { 11852 return fmt.Errorf("unexpected nil of type %T", v) 11853 } 11854 if value == nil { 11855 return nil 11856 } 11857 11858 shape, ok := value.(map[string]interface{}) 11859 if !ok { 11860 return fmt.Errorf("unexpected JSON type %v", value) 11861 } 11862 11863 var sv *types.TlsValidationContext 11864 if *v == nil { 11865 sv = &types.TlsValidationContext{} 11866 } else { 11867 sv = *v 11868 } 11869 11870 for key, value := range shape { 11871 switch key { 11872 case "subjectAlternativeNames": 11873 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 11874 return err 11875 } 11876 11877 case "trust": 11878 if err := awsRestjson1_deserializeDocumentTlsValidationContextTrust(&sv.Trust, value); err != nil { 11879 return err 11880 } 11881 11882 default: 11883 _, _ = key, value 11884 11885 } 11886 } 11887 *v = sv 11888 return nil 11889} 11890 11891func awsRestjson1_deserializeDocumentTlsValidationContextAcmTrust(v **types.TlsValidationContextAcmTrust, value interface{}) error { 11892 if v == nil { 11893 return fmt.Errorf("unexpected nil of type %T", v) 11894 } 11895 if value == nil { 11896 return nil 11897 } 11898 11899 shape, ok := value.(map[string]interface{}) 11900 if !ok { 11901 return fmt.Errorf("unexpected JSON type %v", value) 11902 } 11903 11904 var sv *types.TlsValidationContextAcmTrust 11905 if *v == nil { 11906 sv = &types.TlsValidationContextAcmTrust{} 11907 } else { 11908 sv = *v 11909 } 11910 11911 for key, value := range shape { 11912 switch key { 11913 case "certificateAuthorityArns": 11914 if err := awsRestjson1_deserializeDocumentCertificateAuthorityArns(&sv.CertificateAuthorityArns, value); err != nil { 11915 return err 11916 } 11917 11918 default: 11919 _, _ = key, value 11920 11921 } 11922 } 11923 *v = sv 11924 return nil 11925} 11926 11927func awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(v **types.TlsValidationContextFileTrust, value interface{}) error { 11928 if v == nil { 11929 return fmt.Errorf("unexpected nil of type %T", v) 11930 } 11931 if value == nil { 11932 return nil 11933 } 11934 11935 shape, ok := value.(map[string]interface{}) 11936 if !ok { 11937 return fmt.Errorf("unexpected JSON type %v", value) 11938 } 11939 11940 var sv *types.TlsValidationContextFileTrust 11941 if *v == nil { 11942 sv = &types.TlsValidationContextFileTrust{} 11943 } else { 11944 sv = *v 11945 } 11946 11947 for key, value := range shape { 11948 switch key { 11949 case "certificateChain": 11950 if value != nil { 11951 jtv, ok := value.(string) 11952 if !ok { 11953 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 11954 } 11955 sv.CertificateChain = ptr.String(jtv) 11956 } 11957 11958 default: 11959 _, _ = key, value 11960 11961 } 11962 } 11963 *v = sv 11964 return nil 11965} 11966 11967func awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(v **types.TlsValidationContextSdsTrust, value interface{}) error { 11968 if v == nil { 11969 return fmt.Errorf("unexpected nil of type %T", v) 11970 } 11971 if value == nil { 11972 return nil 11973 } 11974 11975 shape, ok := value.(map[string]interface{}) 11976 if !ok { 11977 return fmt.Errorf("unexpected JSON type %v", value) 11978 } 11979 11980 var sv *types.TlsValidationContextSdsTrust 11981 if *v == nil { 11982 sv = &types.TlsValidationContextSdsTrust{} 11983 } else { 11984 sv = *v 11985 } 11986 11987 for key, value := range shape { 11988 switch key { 11989 case "secretName": 11990 if value != nil { 11991 jtv, ok := value.(string) 11992 if !ok { 11993 return fmt.Errorf("expected SdsSecretName to be of type string, got %T instead", value) 11994 } 11995 sv.SecretName = ptr.String(jtv) 11996 } 11997 11998 default: 11999 _, _ = key, value 12000 12001 } 12002 } 12003 *v = sv 12004 return nil 12005} 12006 12007func awsRestjson1_deserializeDocumentTlsValidationContextTrust(v *types.TlsValidationContextTrust, value interface{}) error { 12008 if v == nil { 12009 return fmt.Errorf("unexpected nil of type %T", v) 12010 } 12011 if value == nil { 12012 return nil 12013 } 12014 12015 shape, ok := value.(map[string]interface{}) 12016 if !ok { 12017 return fmt.Errorf("unexpected JSON type %v", value) 12018 } 12019 12020 var uv types.TlsValidationContextTrust 12021loop: 12022 for key, value := range shape { 12023 if value == nil { 12024 continue 12025 } 12026 switch key { 12027 case "acm": 12028 var mv types.TlsValidationContextAcmTrust 12029 destAddr := &mv 12030 if err := awsRestjson1_deserializeDocumentTlsValidationContextAcmTrust(&destAddr, value); err != nil { 12031 return err 12032 } 12033 mv = *destAddr 12034 uv = &types.TlsValidationContextTrustMemberAcm{Value: mv} 12035 break loop 12036 12037 case "file": 12038 var mv types.TlsValidationContextFileTrust 12039 destAddr := &mv 12040 if err := awsRestjson1_deserializeDocumentTlsValidationContextFileTrust(&destAddr, value); err != nil { 12041 return err 12042 } 12043 mv = *destAddr 12044 uv = &types.TlsValidationContextTrustMemberFile{Value: mv} 12045 break loop 12046 12047 case "sds": 12048 var mv types.TlsValidationContextSdsTrust 12049 destAddr := &mv 12050 if err := awsRestjson1_deserializeDocumentTlsValidationContextSdsTrust(&destAddr, value); err != nil { 12051 return err 12052 } 12053 mv = *destAddr 12054 uv = &types.TlsValidationContextTrustMemberSds{Value: mv} 12055 break loop 12056 12057 default: 12058 uv = &types.UnknownUnionMember{Tag: key} 12059 break loop 12060 12061 } 12062 } 12063 *v = uv 12064 return nil 12065} 12066 12067func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 12068 if v == nil { 12069 return fmt.Errorf("unexpected nil of type %T", v) 12070 } 12071 if value == nil { 12072 return nil 12073 } 12074 12075 shape, ok := value.(map[string]interface{}) 12076 if !ok { 12077 return fmt.Errorf("unexpected JSON type %v", value) 12078 } 12079 12080 var sv *types.TooManyRequestsException 12081 if *v == nil { 12082 sv = &types.TooManyRequestsException{} 12083 } else { 12084 sv = *v 12085 } 12086 12087 for key, value := range shape { 12088 switch key { 12089 case "message": 12090 if value != nil { 12091 jtv, ok := value.(string) 12092 if !ok { 12093 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12094 } 12095 sv.Message = ptr.String(jtv) 12096 } 12097 12098 default: 12099 _, _ = key, value 12100 12101 } 12102 } 12103 *v = sv 12104 return nil 12105} 12106 12107func awsRestjson1_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 12108 if v == nil { 12109 return fmt.Errorf("unexpected nil of type %T", v) 12110 } 12111 if value == nil { 12112 return nil 12113 } 12114 12115 shape, ok := value.(map[string]interface{}) 12116 if !ok { 12117 return fmt.Errorf("unexpected JSON type %v", value) 12118 } 12119 12120 var sv *types.TooManyTagsException 12121 if *v == nil { 12122 sv = &types.TooManyTagsException{} 12123 } else { 12124 sv = *v 12125 } 12126 12127 for key, value := range shape { 12128 switch key { 12129 case "message": 12130 if value != nil { 12131 jtv, ok := value.(string) 12132 if !ok { 12133 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12134 } 12135 sv.Message = ptr.String(jtv) 12136 } 12137 12138 default: 12139 _, _ = key, value 12140 12141 } 12142 } 12143 *v = sv 12144 return nil 12145} 12146 12147func awsRestjson1_deserializeDocumentVirtualGatewayAccessLog(v *types.VirtualGatewayAccessLog, value interface{}) error { 12148 if v == nil { 12149 return fmt.Errorf("unexpected nil of type %T", v) 12150 } 12151 if value == nil { 12152 return nil 12153 } 12154 12155 shape, ok := value.(map[string]interface{}) 12156 if !ok { 12157 return fmt.Errorf("unexpected JSON type %v", value) 12158 } 12159 12160 var uv types.VirtualGatewayAccessLog 12161loop: 12162 for key, value := range shape { 12163 if value == nil { 12164 continue 12165 } 12166 switch key { 12167 case "file": 12168 var mv types.VirtualGatewayFileAccessLog 12169 destAddr := &mv 12170 if err := awsRestjson1_deserializeDocumentVirtualGatewayFileAccessLog(&destAddr, value); err != nil { 12171 return err 12172 } 12173 mv = *destAddr 12174 uv = &types.VirtualGatewayAccessLogMemberFile{Value: mv} 12175 break loop 12176 12177 default: 12178 uv = &types.UnknownUnionMember{Tag: key} 12179 break loop 12180 12181 } 12182 } 12183 *v = uv 12184 return nil 12185} 12186 12187func awsRestjson1_deserializeDocumentVirtualGatewayBackendDefaults(v **types.VirtualGatewayBackendDefaults, value interface{}) error { 12188 if v == nil { 12189 return fmt.Errorf("unexpected nil of type %T", v) 12190 } 12191 if value == nil { 12192 return nil 12193 } 12194 12195 shape, ok := value.(map[string]interface{}) 12196 if !ok { 12197 return fmt.Errorf("unexpected JSON type %v", value) 12198 } 12199 12200 var sv *types.VirtualGatewayBackendDefaults 12201 if *v == nil { 12202 sv = &types.VirtualGatewayBackendDefaults{} 12203 } else { 12204 sv = *v 12205 } 12206 12207 for key, value := range shape { 12208 switch key { 12209 case "clientPolicy": 12210 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientPolicy(&sv.ClientPolicy, value); err != nil { 12211 return err 12212 } 12213 12214 default: 12215 _, _ = key, value 12216 12217 } 12218 } 12219 *v = sv 12220 return nil 12221} 12222 12223func awsRestjson1_deserializeDocumentVirtualGatewayCertificateAuthorityArns(v *[]string, value interface{}) error { 12224 if v == nil { 12225 return fmt.Errorf("unexpected nil of type %T", v) 12226 } 12227 if value == nil { 12228 return nil 12229 } 12230 12231 shape, ok := value.([]interface{}) 12232 if !ok { 12233 return fmt.Errorf("unexpected JSON type %v", value) 12234 } 12235 12236 var cv []string 12237 if *v == nil { 12238 cv = []string{} 12239 } else { 12240 cv = *v 12241 } 12242 12243 for _, value := range shape { 12244 var col string 12245 if value != nil { 12246 jtv, ok := value.(string) 12247 if !ok { 12248 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 12249 } 12250 col = jtv 12251 } 12252 cv = append(cv, col) 12253 12254 } 12255 *v = cv 12256 return nil 12257} 12258 12259func awsRestjson1_deserializeDocumentVirtualGatewayClientPolicy(v **types.VirtualGatewayClientPolicy, value interface{}) error { 12260 if v == nil { 12261 return fmt.Errorf("unexpected nil of type %T", v) 12262 } 12263 if value == nil { 12264 return nil 12265 } 12266 12267 shape, ok := value.(map[string]interface{}) 12268 if !ok { 12269 return fmt.Errorf("unexpected JSON type %v", value) 12270 } 12271 12272 var sv *types.VirtualGatewayClientPolicy 12273 if *v == nil { 12274 sv = &types.VirtualGatewayClientPolicy{} 12275 } else { 12276 sv = *v 12277 } 12278 12279 for key, value := range shape { 12280 switch key { 12281 case "tls": 12282 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientPolicyTls(&sv.Tls, value); err != nil { 12283 return err 12284 } 12285 12286 default: 12287 _, _ = key, value 12288 12289 } 12290 } 12291 *v = sv 12292 return nil 12293} 12294 12295func awsRestjson1_deserializeDocumentVirtualGatewayClientPolicyTls(v **types.VirtualGatewayClientPolicyTls, 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.VirtualGatewayClientPolicyTls 12309 if *v == nil { 12310 sv = &types.VirtualGatewayClientPolicyTls{} 12311 } else { 12312 sv = *v 12313 } 12314 12315 for key, value := range shape { 12316 switch key { 12317 case "certificate": 12318 if err := awsRestjson1_deserializeDocumentVirtualGatewayClientTlsCertificate(&sv.Certificate, value); err != nil { 12319 return err 12320 } 12321 12322 case "enforce": 12323 if value != nil { 12324 jtv, ok := value.(bool) 12325 if !ok { 12326 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 12327 } 12328 sv.Enforce = ptr.Bool(jtv) 12329 } 12330 12331 case "ports": 12332 if err := awsRestjson1_deserializeDocumentPortSet(&sv.Ports, value); err != nil { 12333 return err 12334 } 12335 12336 case "validation": 12337 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContext(&sv.Validation, value); err != nil { 12338 return err 12339 } 12340 12341 default: 12342 _, _ = key, value 12343 12344 } 12345 } 12346 *v = sv 12347 return nil 12348} 12349 12350func awsRestjson1_deserializeDocumentVirtualGatewayClientTlsCertificate(v *types.VirtualGatewayClientTlsCertificate, value interface{}) error { 12351 if v == nil { 12352 return fmt.Errorf("unexpected nil of type %T", v) 12353 } 12354 if value == nil { 12355 return nil 12356 } 12357 12358 shape, ok := value.(map[string]interface{}) 12359 if !ok { 12360 return fmt.Errorf("unexpected JSON type %v", value) 12361 } 12362 12363 var uv types.VirtualGatewayClientTlsCertificate 12364loop: 12365 for key, value := range shape { 12366 if value == nil { 12367 continue 12368 } 12369 switch key { 12370 case "file": 12371 var mv types.VirtualGatewayListenerTlsFileCertificate 12372 destAddr := &mv 12373 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(&destAddr, value); err != nil { 12374 return err 12375 } 12376 mv = *destAddr 12377 uv = &types.VirtualGatewayClientTlsCertificateMemberFile{Value: mv} 12378 break loop 12379 12380 case "sds": 12381 var mv types.VirtualGatewayListenerTlsSdsCertificate 12382 destAddr := &mv 12383 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(&destAddr, value); err != nil { 12384 return err 12385 } 12386 mv = *destAddr 12387 uv = &types.VirtualGatewayClientTlsCertificateMemberSds{Value: mv} 12388 break loop 12389 12390 default: 12391 uv = &types.UnknownUnionMember{Tag: key} 12392 break loop 12393 12394 } 12395 } 12396 *v = uv 12397 return nil 12398} 12399 12400func awsRestjson1_deserializeDocumentVirtualGatewayConnectionPool(v *types.VirtualGatewayConnectionPool, value interface{}) error { 12401 if v == nil { 12402 return fmt.Errorf("unexpected nil of type %T", v) 12403 } 12404 if value == nil { 12405 return nil 12406 } 12407 12408 shape, ok := value.(map[string]interface{}) 12409 if !ok { 12410 return fmt.Errorf("unexpected JSON type %v", value) 12411 } 12412 12413 var uv types.VirtualGatewayConnectionPool 12414loop: 12415 for key, value := range shape { 12416 if value == nil { 12417 continue 12418 } 12419 switch key { 12420 case "grpc": 12421 var mv types.VirtualGatewayGrpcConnectionPool 12422 destAddr := &mv 12423 if err := awsRestjson1_deserializeDocumentVirtualGatewayGrpcConnectionPool(&destAddr, value); err != nil { 12424 return err 12425 } 12426 mv = *destAddr 12427 uv = &types.VirtualGatewayConnectionPoolMemberGrpc{Value: mv} 12428 break loop 12429 12430 case "http": 12431 var mv types.VirtualGatewayHttpConnectionPool 12432 destAddr := &mv 12433 if err := awsRestjson1_deserializeDocumentVirtualGatewayHttpConnectionPool(&destAddr, value); err != nil { 12434 return err 12435 } 12436 mv = *destAddr 12437 uv = &types.VirtualGatewayConnectionPoolMemberHttp{Value: mv} 12438 break loop 12439 12440 case "http2": 12441 var mv types.VirtualGatewayHttp2ConnectionPool 12442 destAddr := &mv 12443 if err := awsRestjson1_deserializeDocumentVirtualGatewayHttp2ConnectionPool(&destAddr, value); err != nil { 12444 return err 12445 } 12446 mv = *destAddr 12447 uv = &types.VirtualGatewayConnectionPoolMemberHttp2{Value: mv} 12448 break loop 12449 12450 default: 12451 uv = &types.UnknownUnionMember{Tag: key} 12452 break loop 12453 12454 } 12455 } 12456 *v = uv 12457 return nil 12458} 12459 12460func awsRestjson1_deserializeDocumentVirtualGatewayData(v **types.VirtualGatewayData, value interface{}) error { 12461 if v == nil { 12462 return fmt.Errorf("unexpected nil of type %T", v) 12463 } 12464 if value == nil { 12465 return nil 12466 } 12467 12468 shape, ok := value.(map[string]interface{}) 12469 if !ok { 12470 return fmt.Errorf("unexpected JSON type %v", value) 12471 } 12472 12473 var sv *types.VirtualGatewayData 12474 if *v == nil { 12475 sv = &types.VirtualGatewayData{} 12476 } else { 12477 sv = *v 12478 } 12479 12480 for key, value := range shape { 12481 switch key { 12482 case "meshName": 12483 if value != nil { 12484 jtv, ok := value.(string) 12485 if !ok { 12486 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 12487 } 12488 sv.MeshName = ptr.String(jtv) 12489 } 12490 12491 case "metadata": 12492 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 12493 return err 12494 } 12495 12496 case "spec": 12497 if err := awsRestjson1_deserializeDocumentVirtualGatewaySpec(&sv.Spec, value); err != nil { 12498 return err 12499 } 12500 12501 case "status": 12502 if err := awsRestjson1_deserializeDocumentVirtualGatewayStatus(&sv.Status, value); err != nil { 12503 return err 12504 } 12505 12506 case "virtualGatewayName": 12507 if value != nil { 12508 jtv, ok := value.(string) 12509 if !ok { 12510 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 12511 } 12512 sv.VirtualGatewayName = ptr.String(jtv) 12513 } 12514 12515 default: 12516 _, _ = key, value 12517 12518 } 12519 } 12520 *v = sv 12521 return nil 12522} 12523 12524func awsRestjson1_deserializeDocumentVirtualGatewayFileAccessLog(v **types.VirtualGatewayFileAccessLog, value interface{}) error { 12525 if v == nil { 12526 return fmt.Errorf("unexpected nil of type %T", v) 12527 } 12528 if value == nil { 12529 return nil 12530 } 12531 12532 shape, ok := value.(map[string]interface{}) 12533 if !ok { 12534 return fmt.Errorf("unexpected JSON type %v", value) 12535 } 12536 12537 var sv *types.VirtualGatewayFileAccessLog 12538 if *v == nil { 12539 sv = &types.VirtualGatewayFileAccessLog{} 12540 } else { 12541 sv = *v 12542 } 12543 12544 for key, value := range shape { 12545 switch key { 12546 case "path": 12547 if value != nil { 12548 jtv, ok := value.(string) 12549 if !ok { 12550 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 12551 } 12552 sv.Path = ptr.String(jtv) 12553 } 12554 12555 default: 12556 _, _ = key, value 12557 12558 } 12559 } 12560 *v = sv 12561 return nil 12562} 12563 12564func awsRestjson1_deserializeDocumentVirtualGatewayGrpcConnectionPool(v **types.VirtualGatewayGrpcConnectionPool, 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.VirtualGatewayGrpcConnectionPool 12578 if *v == nil { 12579 sv = &types.VirtualGatewayGrpcConnectionPool{} 12580 } else { 12581 sv = *v 12582 } 12583 12584 for key, value := range shape { 12585 switch key { 12586 case "maxRequests": 12587 if value != nil { 12588 jtv, ok := value.(json.Number) 12589 if !ok { 12590 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 12591 } 12592 i64, err := jtv.Int64() 12593 if err != nil { 12594 return err 12595 } 12596 sv.MaxRequests = int32(i64) 12597 } 12598 12599 default: 12600 _, _ = key, value 12601 12602 } 12603 } 12604 *v = sv 12605 return nil 12606} 12607 12608func awsRestjson1_deserializeDocumentVirtualGatewayHealthCheckPolicy(v **types.VirtualGatewayHealthCheckPolicy, value interface{}) error { 12609 if v == nil { 12610 return fmt.Errorf("unexpected nil of type %T", v) 12611 } 12612 if value == nil { 12613 return nil 12614 } 12615 12616 shape, ok := value.(map[string]interface{}) 12617 if !ok { 12618 return fmt.Errorf("unexpected JSON type %v", value) 12619 } 12620 12621 var sv *types.VirtualGatewayHealthCheckPolicy 12622 if *v == nil { 12623 sv = &types.VirtualGatewayHealthCheckPolicy{} 12624 } else { 12625 sv = *v 12626 } 12627 12628 for key, value := range shape { 12629 switch key { 12630 case "healthyThreshold": 12631 if value != nil { 12632 jtv, ok := value.(json.Number) 12633 if !ok { 12634 return fmt.Errorf("expected VirtualGatewayHealthCheckThreshold to be json.Number, got %T instead", value) 12635 } 12636 i64, err := jtv.Int64() 12637 if err != nil { 12638 return err 12639 } 12640 sv.HealthyThreshold = int32(i64) 12641 } 12642 12643 case "intervalMillis": 12644 if value != nil { 12645 jtv, ok := value.(json.Number) 12646 if !ok { 12647 return fmt.Errorf("expected VirtualGatewayHealthCheckIntervalMillis to be json.Number, got %T instead", value) 12648 } 12649 i64, err := jtv.Int64() 12650 if err != nil { 12651 return err 12652 } 12653 sv.IntervalMillis = ptr.Int64(i64) 12654 } 12655 12656 case "path": 12657 if value != nil { 12658 jtv, ok := value.(string) 12659 if !ok { 12660 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12661 } 12662 sv.Path = ptr.String(jtv) 12663 } 12664 12665 case "port": 12666 if value != nil { 12667 jtv, ok := value.(json.Number) 12668 if !ok { 12669 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 12670 } 12671 i64, err := jtv.Int64() 12672 if err != nil { 12673 return err 12674 } 12675 sv.Port = int32(i64) 12676 } 12677 12678 case "protocol": 12679 if value != nil { 12680 jtv, ok := value.(string) 12681 if !ok { 12682 return fmt.Errorf("expected VirtualGatewayPortProtocol to be of type string, got %T instead", value) 12683 } 12684 sv.Protocol = types.VirtualGatewayPortProtocol(jtv) 12685 } 12686 12687 case "timeoutMillis": 12688 if value != nil { 12689 jtv, ok := value.(json.Number) 12690 if !ok { 12691 return fmt.Errorf("expected VirtualGatewayHealthCheckTimeoutMillis to be json.Number, got %T instead", value) 12692 } 12693 i64, err := jtv.Int64() 12694 if err != nil { 12695 return err 12696 } 12697 sv.TimeoutMillis = ptr.Int64(i64) 12698 } 12699 12700 case "unhealthyThreshold": 12701 if value != nil { 12702 jtv, ok := value.(json.Number) 12703 if !ok { 12704 return fmt.Errorf("expected VirtualGatewayHealthCheckThreshold to be json.Number, got %T instead", value) 12705 } 12706 i64, err := jtv.Int64() 12707 if err != nil { 12708 return err 12709 } 12710 sv.UnhealthyThreshold = int32(i64) 12711 } 12712 12713 default: 12714 _, _ = key, value 12715 12716 } 12717 } 12718 *v = sv 12719 return nil 12720} 12721 12722func awsRestjson1_deserializeDocumentVirtualGatewayHttp2ConnectionPool(v **types.VirtualGatewayHttp2ConnectionPool, value interface{}) error { 12723 if v == nil { 12724 return fmt.Errorf("unexpected nil of type %T", v) 12725 } 12726 if value == nil { 12727 return nil 12728 } 12729 12730 shape, ok := value.(map[string]interface{}) 12731 if !ok { 12732 return fmt.Errorf("unexpected JSON type %v", value) 12733 } 12734 12735 var sv *types.VirtualGatewayHttp2ConnectionPool 12736 if *v == nil { 12737 sv = &types.VirtualGatewayHttp2ConnectionPool{} 12738 } else { 12739 sv = *v 12740 } 12741 12742 for key, value := range shape { 12743 switch key { 12744 case "maxRequests": 12745 if value != nil { 12746 jtv, ok := value.(json.Number) 12747 if !ok { 12748 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 12749 } 12750 i64, err := jtv.Int64() 12751 if err != nil { 12752 return err 12753 } 12754 sv.MaxRequests = int32(i64) 12755 } 12756 12757 default: 12758 _, _ = key, value 12759 12760 } 12761 } 12762 *v = sv 12763 return nil 12764} 12765 12766func awsRestjson1_deserializeDocumentVirtualGatewayHttpConnectionPool(v **types.VirtualGatewayHttpConnectionPool, value interface{}) error { 12767 if v == nil { 12768 return fmt.Errorf("unexpected nil of type %T", v) 12769 } 12770 if value == nil { 12771 return nil 12772 } 12773 12774 shape, ok := value.(map[string]interface{}) 12775 if !ok { 12776 return fmt.Errorf("unexpected JSON type %v", value) 12777 } 12778 12779 var sv *types.VirtualGatewayHttpConnectionPool 12780 if *v == nil { 12781 sv = &types.VirtualGatewayHttpConnectionPool{} 12782 } else { 12783 sv = *v 12784 } 12785 12786 for key, value := range shape { 12787 switch key { 12788 case "maxConnections": 12789 if value != nil { 12790 jtv, ok := value.(json.Number) 12791 if !ok { 12792 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 12793 } 12794 i64, err := jtv.Int64() 12795 if err != nil { 12796 return err 12797 } 12798 sv.MaxConnections = int32(i64) 12799 } 12800 12801 case "maxPendingRequests": 12802 if value != nil { 12803 jtv, ok := value.(json.Number) 12804 if !ok { 12805 return fmt.Errorf("expected MaxPendingRequests to be json.Number, got %T instead", value) 12806 } 12807 i64, err := jtv.Int64() 12808 if err != nil { 12809 return err 12810 } 12811 sv.MaxPendingRequests = int32(i64) 12812 } 12813 12814 default: 12815 _, _ = key, value 12816 12817 } 12818 } 12819 *v = sv 12820 return nil 12821} 12822 12823func awsRestjson1_deserializeDocumentVirtualGatewayList(v *[]types.VirtualGatewayRef, value interface{}) error { 12824 if v == nil { 12825 return fmt.Errorf("unexpected nil of type %T", v) 12826 } 12827 if value == nil { 12828 return nil 12829 } 12830 12831 shape, ok := value.([]interface{}) 12832 if !ok { 12833 return fmt.Errorf("unexpected JSON type %v", value) 12834 } 12835 12836 var cv []types.VirtualGatewayRef 12837 if *v == nil { 12838 cv = []types.VirtualGatewayRef{} 12839 } else { 12840 cv = *v 12841 } 12842 12843 for _, value := range shape { 12844 var col types.VirtualGatewayRef 12845 destAddr := &col 12846 if err := awsRestjson1_deserializeDocumentVirtualGatewayRef(&destAddr, value); err != nil { 12847 return err 12848 } 12849 col = *destAddr 12850 cv = append(cv, col) 12851 12852 } 12853 *v = cv 12854 return nil 12855} 12856 12857func awsRestjson1_deserializeDocumentVirtualGatewayListener(v **types.VirtualGatewayListener, value interface{}) error { 12858 if v == nil { 12859 return fmt.Errorf("unexpected nil of type %T", v) 12860 } 12861 if value == nil { 12862 return nil 12863 } 12864 12865 shape, ok := value.(map[string]interface{}) 12866 if !ok { 12867 return fmt.Errorf("unexpected JSON type %v", value) 12868 } 12869 12870 var sv *types.VirtualGatewayListener 12871 if *v == nil { 12872 sv = &types.VirtualGatewayListener{} 12873 } else { 12874 sv = *v 12875 } 12876 12877 for key, value := range shape { 12878 switch key { 12879 case "connectionPool": 12880 if err := awsRestjson1_deserializeDocumentVirtualGatewayConnectionPool(&sv.ConnectionPool, value); err != nil { 12881 return err 12882 } 12883 12884 case "healthCheck": 12885 if err := awsRestjson1_deserializeDocumentVirtualGatewayHealthCheckPolicy(&sv.HealthCheck, value); err != nil { 12886 return err 12887 } 12888 12889 case "portMapping": 12890 if err := awsRestjson1_deserializeDocumentVirtualGatewayPortMapping(&sv.PortMapping, value); err != nil { 12891 return err 12892 } 12893 12894 case "tls": 12895 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTls(&sv.Tls, value); err != nil { 12896 return err 12897 } 12898 12899 default: 12900 _, _ = key, value 12901 12902 } 12903 } 12904 *v = sv 12905 return nil 12906} 12907 12908func awsRestjson1_deserializeDocumentVirtualGatewayListeners(v *[]types.VirtualGatewayListener, value interface{}) error { 12909 if v == nil { 12910 return fmt.Errorf("unexpected nil of type %T", v) 12911 } 12912 if value == nil { 12913 return nil 12914 } 12915 12916 shape, ok := value.([]interface{}) 12917 if !ok { 12918 return fmt.Errorf("unexpected JSON type %v", value) 12919 } 12920 12921 var cv []types.VirtualGatewayListener 12922 if *v == nil { 12923 cv = []types.VirtualGatewayListener{} 12924 } else { 12925 cv = *v 12926 } 12927 12928 for _, value := range shape { 12929 var col types.VirtualGatewayListener 12930 destAddr := &col 12931 if err := awsRestjson1_deserializeDocumentVirtualGatewayListener(&destAddr, value); err != nil { 12932 return err 12933 } 12934 col = *destAddr 12935 cv = append(cv, col) 12936 12937 } 12938 *v = cv 12939 return nil 12940} 12941 12942func awsRestjson1_deserializeDocumentVirtualGatewayListenerTls(v **types.VirtualGatewayListenerTls, value interface{}) error { 12943 if v == nil { 12944 return fmt.Errorf("unexpected nil of type %T", v) 12945 } 12946 if value == nil { 12947 return nil 12948 } 12949 12950 shape, ok := value.(map[string]interface{}) 12951 if !ok { 12952 return fmt.Errorf("unexpected JSON type %v", value) 12953 } 12954 12955 var sv *types.VirtualGatewayListenerTls 12956 if *v == nil { 12957 sv = &types.VirtualGatewayListenerTls{} 12958 } else { 12959 sv = *v 12960 } 12961 12962 for key, value := range shape { 12963 switch key { 12964 case "certificate": 12965 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsCertificate(&sv.Certificate, value); err != nil { 12966 return err 12967 } 12968 12969 case "mode": 12970 if value != nil { 12971 jtv, ok := value.(string) 12972 if !ok { 12973 return fmt.Errorf("expected VirtualGatewayListenerTlsMode to be of type string, got %T instead", value) 12974 } 12975 sv.Mode = types.VirtualGatewayListenerTlsMode(jtv) 12976 } 12977 12978 case "validation": 12979 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContext(&sv.Validation, value); err != nil { 12980 return err 12981 } 12982 12983 default: 12984 _, _ = key, value 12985 12986 } 12987 } 12988 *v = sv 12989 return nil 12990} 12991 12992func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsAcmCertificate(v **types.VirtualGatewayListenerTlsAcmCertificate, value interface{}) error { 12993 if v == nil { 12994 return fmt.Errorf("unexpected nil of type %T", v) 12995 } 12996 if value == nil { 12997 return nil 12998 } 12999 13000 shape, ok := value.(map[string]interface{}) 13001 if !ok { 13002 return fmt.Errorf("unexpected JSON type %v", value) 13003 } 13004 13005 var sv *types.VirtualGatewayListenerTlsAcmCertificate 13006 if *v == nil { 13007 sv = &types.VirtualGatewayListenerTlsAcmCertificate{} 13008 } else { 13009 sv = *v 13010 } 13011 13012 for key, value := range shape { 13013 switch key { 13014 case "certificateArn": 13015 if value != nil { 13016 jtv, ok := value.(string) 13017 if !ok { 13018 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 13019 } 13020 sv.CertificateArn = ptr.String(jtv) 13021 } 13022 13023 default: 13024 _, _ = key, value 13025 13026 } 13027 } 13028 *v = sv 13029 return nil 13030} 13031 13032func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsCertificate(v *types.VirtualGatewayListenerTlsCertificate, value interface{}) error { 13033 if v == nil { 13034 return fmt.Errorf("unexpected nil of type %T", v) 13035 } 13036 if value == nil { 13037 return nil 13038 } 13039 13040 shape, ok := value.(map[string]interface{}) 13041 if !ok { 13042 return fmt.Errorf("unexpected JSON type %v", value) 13043 } 13044 13045 var uv types.VirtualGatewayListenerTlsCertificate 13046loop: 13047 for key, value := range shape { 13048 if value == nil { 13049 continue 13050 } 13051 switch key { 13052 case "acm": 13053 var mv types.VirtualGatewayListenerTlsAcmCertificate 13054 destAddr := &mv 13055 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsAcmCertificate(&destAddr, value); err != nil { 13056 return err 13057 } 13058 mv = *destAddr 13059 uv = &types.VirtualGatewayListenerTlsCertificateMemberAcm{Value: mv} 13060 break loop 13061 13062 case "file": 13063 var mv types.VirtualGatewayListenerTlsFileCertificate 13064 destAddr := &mv 13065 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(&destAddr, value); err != nil { 13066 return err 13067 } 13068 mv = *destAddr 13069 uv = &types.VirtualGatewayListenerTlsCertificateMemberFile{Value: mv} 13070 break loop 13071 13072 case "sds": 13073 var mv types.VirtualGatewayListenerTlsSdsCertificate 13074 destAddr := &mv 13075 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(&destAddr, value); err != nil { 13076 return err 13077 } 13078 mv = *destAddr 13079 uv = &types.VirtualGatewayListenerTlsCertificateMemberSds{Value: mv} 13080 break loop 13081 13082 default: 13083 uv = &types.UnknownUnionMember{Tag: key} 13084 break loop 13085 13086 } 13087 } 13088 *v = uv 13089 return nil 13090} 13091 13092func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsFileCertificate(v **types.VirtualGatewayListenerTlsFileCertificate, value interface{}) error { 13093 if v == nil { 13094 return fmt.Errorf("unexpected nil of type %T", v) 13095 } 13096 if value == nil { 13097 return nil 13098 } 13099 13100 shape, ok := value.(map[string]interface{}) 13101 if !ok { 13102 return fmt.Errorf("unexpected JSON type %v", value) 13103 } 13104 13105 var sv *types.VirtualGatewayListenerTlsFileCertificate 13106 if *v == nil { 13107 sv = &types.VirtualGatewayListenerTlsFileCertificate{} 13108 } else { 13109 sv = *v 13110 } 13111 13112 for key, value := range shape { 13113 switch key { 13114 case "certificateChain": 13115 if value != nil { 13116 jtv, ok := value.(string) 13117 if !ok { 13118 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 13119 } 13120 sv.CertificateChain = ptr.String(jtv) 13121 } 13122 13123 case "privateKey": 13124 if value != nil { 13125 jtv, ok := value.(string) 13126 if !ok { 13127 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 13128 } 13129 sv.PrivateKey = ptr.String(jtv) 13130 } 13131 13132 default: 13133 _, _ = key, value 13134 13135 } 13136 } 13137 *v = sv 13138 return nil 13139} 13140 13141func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsSdsCertificate(v **types.VirtualGatewayListenerTlsSdsCertificate, value interface{}) error { 13142 if v == nil { 13143 return fmt.Errorf("unexpected nil of type %T", v) 13144 } 13145 if value == nil { 13146 return nil 13147 } 13148 13149 shape, ok := value.(map[string]interface{}) 13150 if !ok { 13151 return fmt.Errorf("unexpected JSON type %v", value) 13152 } 13153 13154 var sv *types.VirtualGatewayListenerTlsSdsCertificate 13155 if *v == nil { 13156 sv = &types.VirtualGatewayListenerTlsSdsCertificate{} 13157 } else { 13158 sv = *v 13159 } 13160 13161 for key, value := range shape { 13162 switch key { 13163 case "secretName": 13164 if value != nil { 13165 jtv, ok := value.(string) 13166 if !ok { 13167 return fmt.Errorf("expected VirtualGatewaySdsSecretName to be of type string, got %T instead", value) 13168 } 13169 sv.SecretName = ptr.String(jtv) 13170 } 13171 13172 default: 13173 _, _ = key, value 13174 13175 } 13176 } 13177 *v = sv 13178 return nil 13179} 13180 13181func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContext(v **types.VirtualGatewayListenerTlsValidationContext, value interface{}) error { 13182 if v == nil { 13183 return fmt.Errorf("unexpected nil of type %T", v) 13184 } 13185 if value == nil { 13186 return nil 13187 } 13188 13189 shape, ok := value.(map[string]interface{}) 13190 if !ok { 13191 return fmt.Errorf("unexpected JSON type %v", value) 13192 } 13193 13194 var sv *types.VirtualGatewayListenerTlsValidationContext 13195 if *v == nil { 13196 sv = &types.VirtualGatewayListenerTlsValidationContext{} 13197 } else { 13198 sv = *v 13199 } 13200 13201 for key, value := range shape { 13202 switch key { 13203 case "subjectAlternativeNames": 13204 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 13205 return err 13206 } 13207 13208 case "trust": 13209 if err := awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContextTrust(&sv.Trust, value); err != nil { 13210 return err 13211 } 13212 13213 default: 13214 _, _ = key, value 13215 13216 } 13217 } 13218 *v = sv 13219 return nil 13220} 13221 13222func awsRestjson1_deserializeDocumentVirtualGatewayListenerTlsValidationContextTrust(v *types.VirtualGatewayListenerTlsValidationContextTrust, value interface{}) error { 13223 if v == nil { 13224 return fmt.Errorf("unexpected nil of type %T", v) 13225 } 13226 if value == nil { 13227 return nil 13228 } 13229 13230 shape, ok := value.(map[string]interface{}) 13231 if !ok { 13232 return fmt.Errorf("unexpected JSON type %v", value) 13233 } 13234 13235 var uv types.VirtualGatewayListenerTlsValidationContextTrust 13236loop: 13237 for key, value := range shape { 13238 if value == nil { 13239 continue 13240 } 13241 switch key { 13242 case "file": 13243 var mv types.VirtualGatewayTlsValidationContextFileTrust 13244 destAddr := &mv 13245 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(&destAddr, value); err != nil { 13246 return err 13247 } 13248 mv = *destAddr 13249 uv = &types.VirtualGatewayListenerTlsValidationContextTrustMemberFile{Value: mv} 13250 break loop 13251 13252 case "sds": 13253 var mv types.VirtualGatewayTlsValidationContextSdsTrust 13254 destAddr := &mv 13255 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(&destAddr, value); err != nil { 13256 return err 13257 } 13258 mv = *destAddr 13259 uv = &types.VirtualGatewayListenerTlsValidationContextTrustMemberSds{Value: mv} 13260 break loop 13261 13262 default: 13263 uv = &types.UnknownUnionMember{Tag: key} 13264 break loop 13265 13266 } 13267 } 13268 *v = uv 13269 return nil 13270} 13271 13272func awsRestjson1_deserializeDocumentVirtualGatewayLogging(v **types.VirtualGatewayLogging, value interface{}) error { 13273 if v == nil { 13274 return fmt.Errorf("unexpected nil of type %T", v) 13275 } 13276 if value == nil { 13277 return nil 13278 } 13279 13280 shape, ok := value.(map[string]interface{}) 13281 if !ok { 13282 return fmt.Errorf("unexpected JSON type %v", value) 13283 } 13284 13285 var sv *types.VirtualGatewayLogging 13286 if *v == nil { 13287 sv = &types.VirtualGatewayLogging{} 13288 } else { 13289 sv = *v 13290 } 13291 13292 for key, value := range shape { 13293 switch key { 13294 case "accessLog": 13295 if err := awsRestjson1_deserializeDocumentVirtualGatewayAccessLog(&sv.AccessLog, value); err != nil { 13296 return err 13297 } 13298 13299 default: 13300 _, _ = key, value 13301 13302 } 13303 } 13304 *v = sv 13305 return nil 13306} 13307 13308func awsRestjson1_deserializeDocumentVirtualGatewayPortMapping(v **types.VirtualGatewayPortMapping, value interface{}) error { 13309 if v == nil { 13310 return fmt.Errorf("unexpected nil of type %T", v) 13311 } 13312 if value == nil { 13313 return nil 13314 } 13315 13316 shape, ok := value.(map[string]interface{}) 13317 if !ok { 13318 return fmt.Errorf("unexpected JSON type %v", value) 13319 } 13320 13321 var sv *types.VirtualGatewayPortMapping 13322 if *v == nil { 13323 sv = &types.VirtualGatewayPortMapping{} 13324 } else { 13325 sv = *v 13326 } 13327 13328 for key, value := range shape { 13329 switch key { 13330 case "port": 13331 if value != nil { 13332 jtv, ok := value.(json.Number) 13333 if !ok { 13334 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 13335 } 13336 i64, err := jtv.Int64() 13337 if err != nil { 13338 return err 13339 } 13340 sv.Port = int32(i64) 13341 } 13342 13343 case "protocol": 13344 if value != nil { 13345 jtv, ok := value.(string) 13346 if !ok { 13347 return fmt.Errorf("expected VirtualGatewayPortProtocol to be of type string, got %T instead", value) 13348 } 13349 sv.Protocol = types.VirtualGatewayPortProtocol(jtv) 13350 } 13351 13352 default: 13353 _, _ = key, value 13354 13355 } 13356 } 13357 *v = sv 13358 return nil 13359} 13360 13361func awsRestjson1_deserializeDocumentVirtualGatewayRef(v **types.VirtualGatewayRef, value interface{}) error { 13362 if v == nil { 13363 return fmt.Errorf("unexpected nil of type %T", v) 13364 } 13365 if value == nil { 13366 return nil 13367 } 13368 13369 shape, ok := value.(map[string]interface{}) 13370 if !ok { 13371 return fmt.Errorf("unexpected JSON type %v", value) 13372 } 13373 13374 var sv *types.VirtualGatewayRef 13375 if *v == nil { 13376 sv = &types.VirtualGatewayRef{} 13377 } else { 13378 sv = *v 13379 } 13380 13381 for key, value := range shape { 13382 switch key { 13383 case "arn": 13384 if value != nil { 13385 jtv, ok := value.(string) 13386 if !ok { 13387 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 13388 } 13389 sv.Arn = ptr.String(jtv) 13390 } 13391 13392 case "createdAt": 13393 if value != nil { 13394 switch jtv := value.(type) { 13395 case json.Number: 13396 f64, err := jtv.Float64() 13397 if err != nil { 13398 return err 13399 } 13400 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13401 13402 default: 13403 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 13404 13405 } 13406 } 13407 13408 case "lastUpdatedAt": 13409 if value != nil { 13410 switch jtv := value.(type) { 13411 case json.Number: 13412 f64, err := jtv.Float64() 13413 if err != nil { 13414 return err 13415 } 13416 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13417 13418 default: 13419 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 13420 13421 } 13422 } 13423 13424 case "meshName": 13425 if value != nil { 13426 jtv, ok := value.(string) 13427 if !ok { 13428 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13429 } 13430 sv.MeshName = ptr.String(jtv) 13431 } 13432 13433 case "meshOwner": 13434 if value != nil { 13435 jtv, ok := value.(string) 13436 if !ok { 13437 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13438 } 13439 sv.MeshOwner = ptr.String(jtv) 13440 } 13441 13442 case "resourceOwner": 13443 if value != nil { 13444 jtv, ok := value.(string) 13445 if !ok { 13446 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 13447 } 13448 sv.ResourceOwner = ptr.String(jtv) 13449 } 13450 13451 case "version": 13452 if value != nil { 13453 jtv, ok := value.(json.Number) 13454 if !ok { 13455 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 13456 } 13457 i64, err := jtv.Int64() 13458 if err != nil { 13459 return err 13460 } 13461 sv.Version = ptr.Int64(i64) 13462 } 13463 13464 case "virtualGatewayName": 13465 if value != nil { 13466 jtv, ok := value.(string) 13467 if !ok { 13468 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13469 } 13470 sv.VirtualGatewayName = ptr.String(jtv) 13471 } 13472 13473 default: 13474 _, _ = key, value 13475 13476 } 13477 } 13478 *v = sv 13479 return nil 13480} 13481 13482func awsRestjson1_deserializeDocumentVirtualGatewaySpec(v **types.VirtualGatewaySpec, value interface{}) error { 13483 if v == nil { 13484 return fmt.Errorf("unexpected nil of type %T", v) 13485 } 13486 if value == nil { 13487 return nil 13488 } 13489 13490 shape, ok := value.(map[string]interface{}) 13491 if !ok { 13492 return fmt.Errorf("unexpected JSON type %v", value) 13493 } 13494 13495 var sv *types.VirtualGatewaySpec 13496 if *v == nil { 13497 sv = &types.VirtualGatewaySpec{} 13498 } else { 13499 sv = *v 13500 } 13501 13502 for key, value := range shape { 13503 switch key { 13504 case "backendDefaults": 13505 if err := awsRestjson1_deserializeDocumentVirtualGatewayBackendDefaults(&sv.BackendDefaults, value); err != nil { 13506 return err 13507 } 13508 13509 case "listeners": 13510 if err := awsRestjson1_deserializeDocumentVirtualGatewayListeners(&sv.Listeners, value); err != nil { 13511 return err 13512 } 13513 13514 case "logging": 13515 if err := awsRestjson1_deserializeDocumentVirtualGatewayLogging(&sv.Logging, value); err != nil { 13516 return err 13517 } 13518 13519 default: 13520 _, _ = key, value 13521 13522 } 13523 } 13524 *v = sv 13525 return nil 13526} 13527 13528func awsRestjson1_deserializeDocumentVirtualGatewayStatus(v **types.VirtualGatewayStatus, value interface{}) error { 13529 if v == nil { 13530 return fmt.Errorf("unexpected nil of type %T", v) 13531 } 13532 if value == nil { 13533 return nil 13534 } 13535 13536 shape, ok := value.(map[string]interface{}) 13537 if !ok { 13538 return fmt.Errorf("unexpected JSON type %v", value) 13539 } 13540 13541 var sv *types.VirtualGatewayStatus 13542 if *v == nil { 13543 sv = &types.VirtualGatewayStatus{} 13544 } else { 13545 sv = *v 13546 } 13547 13548 for key, value := range shape { 13549 switch key { 13550 case "status": 13551 if value != nil { 13552 jtv, ok := value.(string) 13553 if !ok { 13554 return fmt.Errorf("expected VirtualGatewayStatusCode to be of type string, got %T instead", value) 13555 } 13556 sv.Status = types.VirtualGatewayStatusCode(jtv) 13557 } 13558 13559 default: 13560 _, _ = key, value 13561 13562 } 13563 } 13564 *v = sv 13565 return nil 13566} 13567 13568func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContext(v **types.VirtualGatewayTlsValidationContext, value interface{}) error { 13569 if v == nil { 13570 return fmt.Errorf("unexpected nil of type %T", v) 13571 } 13572 if value == nil { 13573 return nil 13574 } 13575 13576 shape, ok := value.(map[string]interface{}) 13577 if !ok { 13578 return fmt.Errorf("unexpected JSON type %v", value) 13579 } 13580 13581 var sv *types.VirtualGatewayTlsValidationContext 13582 if *v == nil { 13583 sv = &types.VirtualGatewayTlsValidationContext{} 13584 } else { 13585 sv = *v 13586 } 13587 13588 for key, value := range shape { 13589 switch key { 13590 case "subjectAlternativeNames": 13591 if err := awsRestjson1_deserializeDocumentSubjectAlternativeNames(&sv.SubjectAlternativeNames, value); err != nil { 13592 return err 13593 } 13594 13595 case "trust": 13596 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextTrust(&sv.Trust, value); err != nil { 13597 return err 13598 } 13599 13600 default: 13601 _, _ = key, value 13602 13603 } 13604 } 13605 *v = sv 13606 return nil 13607} 13608 13609func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextAcmTrust(v **types.VirtualGatewayTlsValidationContextAcmTrust, value interface{}) error { 13610 if v == nil { 13611 return fmt.Errorf("unexpected nil of type %T", v) 13612 } 13613 if value == nil { 13614 return nil 13615 } 13616 13617 shape, ok := value.(map[string]interface{}) 13618 if !ok { 13619 return fmt.Errorf("unexpected JSON type %v", value) 13620 } 13621 13622 var sv *types.VirtualGatewayTlsValidationContextAcmTrust 13623 if *v == nil { 13624 sv = &types.VirtualGatewayTlsValidationContextAcmTrust{} 13625 } else { 13626 sv = *v 13627 } 13628 13629 for key, value := range shape { 13630 switch key { 13631 case "certificateAuthorityArns": 13632 if err := awsRestjson1_deserializeDocumentVirtualGatewayCertificateAuthorityArns(&sv.CertificateAuthorityArns, value); err != nil { 13633 return err 13634 } 13635 13636 default: 13637 _, _ = key, value 13638 13639 } 13640 } 13641 *v = sv 13642 return nil 13643} 13644 13645func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(v **types.VirtualGatewayTlsValidationContextFileTrust, value interface{}) error { 13646 if v == nil { 13647 return fmt.Errorf("unexpected nil of type %T", v) 13648 } 13649 if value == nil { 13650 return nil 13651 } 13652 13653 shape, ok := value.(map[string]interface{}) 13654 if !ok { 13655 return fmt.Errorf("unexpected JSON type %v", value) 13656 } 13657 13658 var sv *types.VirtualGatewayTlsValidationContextFileTrust 13659 if *v == nil { 13660 sv = &types.VirtualGatewayTlsValidationContextFileTrust{} 13661 } else { 13662 sv = *v 13663 } 13664 13665 for key, value := range shape { 13666 switch key { 13667 case "certificateChain": 13668 if value != nil { 13669 jtv, ok := value.(string) 13670 if !ok { 13671 return fmt.Errorf("expected FilePath to be of type string, got %T instead", value) 13672 } 13673 sv.CertificateChain = ptr.String(jtv) 13674 } 13675 13676 default: 13677 _, _ = key, value 13678 13679 } 13680 } 13681 *v = sv 13682 return nil 13683} 13684 13685func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(v **types.VirtualGatewayTlsValidationContextSdsTrust, value interface{}) error { 13686 if v == nil { 13687 return fmt.Errorf("unexpected nil of type %T", v) 13688 } 13689 if value == nil { 13690 return nil 13691 } 13692 13693 shape, ok := value.(map[string]interface{}) 13694 if !ok { 13695 return fmt.Errorf("unexpected JSON type %v", value) 13696 } 13697 13698 var sv *types.VirtualGatewayTlsValidationContextSdsTrust 13699 if *v == nil { 13700 sv = &types.VirtualGatewayTlsValidationContextSdsTrust{} 13701 } else { 13702 sv = *v 13703 } 13704 13705 for key, value := range shape { 13706 switch key { 13707 case "secretName": 13708 if value != nil { 13709 jtv, ok := value.(string) 13710 if !ok { 13711 return fmt.Errorf("expected VirtualGatewaySdsSecretName to be of type string, got %T instead", value) 13712 } 13713 sv.SecretName = ptr.String(jtv) 13714 } 13715 13716 default: 13717 _, _ = key, value 13718 13719 } 13720 } 13721 *v = sv 13722 return nil 13723} 13724 13725func awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextTrust(v *types.VirtualGatewayTlsValidationContextTrust, value interface{}) error { 13726 if v == nil { 13727 return fmt.Errorf("unexpected nil of type %T", v) 13728 } 13729 if value == nil { 13730 return nil 13731 } 13732 13733 shape, ok := value.(map[string]interface{}) 13734 if !ok { 13735 return fmt.Errorf("unexpected JSON type %v", value) 13736 } 13737 13738 var uv types.VirtualGatewayTlsValidationContextTrust 13739loop: 13740 for key, value := range shape { 13741 if value == nil { 13742 continue 13743 } 13744 switch key { 13745 case "acm": 13746 var mv types.VirtualGatewayTlsValidationContextAcmTrust 13747 destAddr := &mv 13748 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextAcmTrust(&destAddr, value); err != nil { 13749 return err 13750 } 13751 mv = *destAddr 13752 uv = &types.VirtualGatewayTlsValidationContextTrustMemberAcm{Value: mv} 13753 break loop 13754 13755 case "file": 13756 var mv types.VirtualGatewayTlsValidationContextFileTrust 13757 destAddr := &mv 13758 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextFileTrust(&destAddr, value); err != nil { 13759 return err 13760 } 13761 mv = *destAddr 13762 uv = &types.VirtualGatewayTlsValidationContextTrustMemberFile{Value: mv} 13763 break loop 13764 13765 case "sds": 13766 var mv types.VirtualGatewayTlsValidationContextSdsTrust 13767 destAddr := &mv 13768 if err := awsRestjson1_deserializeDocumentVirtualGatewayTlsValidationContextSdsTrust(&destAddr, value); err != nil { 13769 return err 13770 } 13771 mv = *destAddr 13772 uv = &types.VirtualGatewayTlsValidationContextTrustMemberSds{Value: mv} 13773 break loop 13774 13775 default: 13776 uv = &types.UnknownUnionMember{Tag: key} 13777 break loop 13778 13779 } 13780 } 13781 *v = uv 13782 return nil 13783} 13784 13785func awsRestjson1_deserializeDocumentVirtualNodeConnectionPool(v *types.VirtualNodeConnectionPool, value interface{}) error { 13786 if v == nil { 13787 return fmt.Errorf("unexpected nil of type %T", v) 13788 } 13789 if value == nil { 13790 return nil 13791 } 13792 13793 shape, ok := value.(map[string]interface{}) 13794 if !ok { 13795 return fmt.Errorf("unexpected JSON type %v", value) 13796 } 13797 13798 var uv types.VirtualNodeConnectionPool 13799loop: 13800 for key, value := range shape { 13801 if value == nil { 13802 continue 13803 } 13804 switch key { 13805 case "grpc": 13806 var mv types.VirtualNodeGrpcConnectionPool 13807 destAddr := &mv 13808 if err := awsRestjson1_deserializeDocumentVirtualNodeGrpcConnectionPool(&destAddr, value); err != nil { 13809 return err 13810 } 13811 mv = *destAddr 13812 uv = &types.VirtualNodeConnectionPoolMemberGrpc{Value: mv} 13813 break loop 13814 13815 case "http": 13816 var mv types.VirtualNodeHttpConnectionPool 13817 destAddr := &mv 13818 if err := awsRestjson1_deserializeDocumentVirtualNodeHttpConnectionPool(&destAddr, value); err != nil { 13819 return err 13820 } 13821 mv = *destAddr 13822 uv = &types.VirtualNodeConnectionPoolMemberHttp{Value: mv} 13823 break loop 13824 13825 case "http2": 13826 var mv types.VirtualNodeHttp2ConnectionPool 13827 destAddr := &mv 13828 if err := awsRestjson1_deserializeDocumentVirtualNodeHttp2ConnectionPool(&destAddr, value); err != nil { 13829 return err 13830 } 13831 mv = *destAddr 13832 uv = &types.VirtualNodeConnectionPoolMemberHttp2{Value: mv} 13833 break loop 13834 13835 case "tcp": 13836 var mv types.VirtualNodeTcpConnectionPool 13837 destAddr := &mv 13838 if err := awsRestjson1_deserializeDocumentVirtualNodeTcpConnectionPool(&destAddr, value); err != nil { 13839 return err 13840 } 13841 mv = *destAddr 13842 uv = &types.VirtualNodeConnectionPoolMemberTcp{Value: mv} 13843 break loop 13844 13845 default: 13846 uv = &types.UnknownUnionMember{Tag: key} 13847 break loop 13848 13849 } 13850 } 13851 *v = uv 13852 return nil 13853} 13854 13855func awsRestjson1_deserializeDocumentVirtualNodeData(v **types.VirtualNodeData, value interface{}) error { 13856 if v == nil { 13857 return fmt.Errorf("unexpected nil of type %T", v) 13858 } 13859 if value == nil { 13860 return nil 13861 } 13862 13863 shape, ok := value.(map[string]interface{}) 13864 if !ok { 13865 return fmt.Errorf("unexpected JSON type %v", value) 13866 } 13867 13868 var sv *types.VirtualNodeData 13869 if *v == nil { 13870 sv = &types.VirtualNodeData{} 13871 } else { 13872 sv = *v 13873 } 13874 13875 for key, value := range shape { 13876 switch key { 13877 case "meshName": 13878 if value != nil { 13879 jtv, ok := value.(string) 13880 if !ok { 13881 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13882 } 13883 sv.MeshName = ptr.String(jtv) 13884 } 13885 13886 case "metadata": 13887 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 13888 return err 13889 } 13890 13891 case "spec": 13892 if err := awsRestjson1_deserializeDocumentVirtualNodeSpec(&sv.Spec, value); err != nil { 13893 return err 13894 } 13895 13896 case "status": 13897 if err := awsRestjson1_deserializeDocumentVirtualNodeStatus(&sv.Status, value); err != nil { 13898 return err 13899 } 13900 13901 case "virtualNodeName": 13902 if value != nil { 13903 jtv, ok := value.(string) 13904 if !ok { 13905 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 13906 } 13907 sv.VirtualNodeName = ptr.String(jtv) 13908 } 13909 13910 default: 13911 _, _ = key, value 13912 13913 } 13914 } 13915 *v = sv 13916 return nil 13917} 13918 13919func awsRestjson1_deserializeDocumentVirtualNodeGrpcConnectionPool(v **types.VirtualNodeGrpcConnectionPool, value interface{}) error { 13920 if v == nil { 13921 return fmt.Errorf("unexpected nil of type %T", v) 13922 } 13923 if value == nil { 13924 return nil 13925 } 13926 13927 shape, ok := value.(map[string]interface{}) 13928 if !ok { 13929 return fmt.Errorf("unexpected JSON type %v", value) 13930 } 13931 13932 var sv *types.VirtualNodeGrpcConnectionPool 13933 if *v == nil { 13934 sv = &types.VirtualNodeGrpcConnectionPool{} 13935 } else { 13936 sv = *v 13937 } 13938 13939 for key, value := range shape { 13940 switch key { 13941 case "maxRequests": 13942 if value != nil { 13943 jtv, ok := value.(json.Number) 13944 if !ok { 13945 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 13946 } 13947 i64, err := jtv.Int64() 13948 if err != nil { 13949 return err 13950 } 13951 sv.MaxRequests = int32(i64) 13952 } 13953 13954 default: 13955 _, _ = key, value 13956 13957 } 13958 } 13959 *v = sv 13960 return nil 13961} 13962 13963func awsRestjson1_deserializeDocumentVirtualNodeHttp2ConnectionPool(v **types.VirtualNodeHttp2ConnectionPool, value interface{}) error { 13964 if v == nil { 13965 return fmt.Errorf("unexpected nil of type %T", v) 13966 } 13967 if value == nil { 13968 return nil 13969 } 13970 13971 shape, ok := value.(map[string]interface{}) 13972 if !ok { 13973 return fmt.Errorf("unexpected JSON type %v", value) 13974 } 13975 13976 var sv *types.VirtualNodeHttp2ConnectionPool 13977 if *v == nil { 13978 sv = &types.VirtualNodeHttp2ConnectionPool{} 13979 } else { 13980 sv = *v 13981 } 13982 13983 for key, value := range shape { 13984 switch key { 13985 case "maxRequests": 13986 if value != nil { 13987 jtv, ok := value.(json.Number) 13988 if !ok { 13989 return fmt.Errorf("expected MaxRequests to be json.Number, got %T instead", value) 13990 } 13991 i64, err := jtv.Int64() 13992 if err != nil { 13993 return err 13994 } 13995 sv.MaxRequests = int32(i64) 13996 } 13997 13998 default: 13999 _, _ = key, value 14000 14001 } 14002 } 14003 *v = sv 14004 return nil 14005} 14006 14007func awsRestjson1_deserializeDocumentVirtualNodeHttpConnectionPool(v **types.VirtualNodeHttpConnectionPool, value interface{}) error { 14008 if v == nil { 14009 return fmt.Errorf("unexpected nil of type %T", v) 14010 } 14011 if value == nil { 14012 return nil 14013 } 14014 14015 shape, ok := value.(map[string]interface{}) 14016 if !ok { 14017 return fmt.Errorf("unexpected JSON type %v", value) 14018 } 14019 14020 var sv *types.VirtualNodeHttpConnectionPool 14021 if *v == nil { 14022 sv = &types.VirtualNodeHttpConnectionPool{} 14023 } else { 14024 sv = *v 14025 } 14026 14027 for key, value := range shape { 14028 switch key { 14029 case "maxConnections": 14030 if value != nil { 14031 jtv, ok := value.(json.Number) 14032 if !ok { 14033 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 14034 } 14035 i64, err := jtv.Int64() 14036 if err != nil { 14037 return err 14038 } 14039 sv.MaxConnections = int32(i64) 14040 } 14041 14042 case "maxPendingRequests": 14043 if value != nil { 14044 jtv, ok := value.(json.Number) 14045 if !ok { 14046 return fmt.Errorf("expected MaxPendingRequests to be json.Number, got %T instead", value) 14047 } 14048 i64, err := jtv.Int64() 14049 if err != nil { 14050 return err 14051 } 14052 sv.MaxPendingRequests = int32(i64) 14053 } 14054 14055 default: 14056 _, _ = key, value 14057 14058 } 14059 } 14060 *v = sv 14061 return nil 14062} 14063 14064func awsRestjson1_deserializeDocumentVirtualNodeList(v *[]types.VirtualNodeRef, value interface{}) error { 14065 if v == nil { 14066 return fmt.Errorf("unexpected nil of type %T", v) 14067 } 14068 if value == nil { 14069 return nil 14070 } 14071 14072 shape, ok := value.([]interface{}) 14073 if !ok { 14074 return fmt.Errorf("unexpected JSON type %v", value) 14075 } 14076 14077 var cv []types.VirtualNodeRef 14078 if *v == nil { 14079 cv = []types.VirtualNodeRef{} 14080 } else { 14081 cv = *v 14082 } 14083 14084 for _, value := range shape { 14085 var col types.VirtualNodeRef 14086 destAddr := &col 14087 if err := awsRestjson1_deserializeDocumentVirtualNodeRef(&destAddr, value); err != nil { 14088 return err 14089 } 14090 col = *destAddr 14091 cv = append(cv, col) 14092 14093 } 14094 *v = cv 14095 return nil 14096} 14097 14098func awsRestjson1_deserializeDocumentVirtualNodeRef(v **types.VirtualNodeRef, 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.(map[string]interface{}) 14107 if !ok { 14108 return fmt.Errorf("unexpected JSON type %v", value) 14109 } 14110 14111 var sv *types.VirtualNodeRef 14112 if *v == nil { 14113 sv = &types.VirtualNodeRef{} 14114 } else { 14115 sv = *v 14116 } 14117 14118 for key, value := range shape { 14119 switch key { 14120 case "arn": 14121 if value != nil { 14122 jtv, ok := value.(string) 14123 if !ok { 14124 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14125 } 14126 sv.Arn = ptr.String(jtv) 14127 } 14128 14129 case "createdAt": 14130 if value != nil { 14131 switch jtv := value.(type) { 14132 case json.Number: 14133 f64, err := jtv.Float64() 14134 if err != nil { 14135 return err 14136 } 14137 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14138 14139 default: 14140 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 14141 14142 } 14143 } 14144 14145 case "lastUpdatedAt": 14146 if value != nil { 14147 switch jtv := value.(type) { 14148 case json.Number: 14149 f64, err := jtv.Float64() 14150 if err != nil { 14151 return err 14152 } 14153 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14154 14155 default: 14156 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 14157 14158 } 14159 } 14160 14161 case "meshName": 14162 if value != nil { 14163 jtv, ok := value.(string) 14164 if !ok { 14165 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14166 } 14167 sv.MeshName = ptr.String(jtv) 14168 } 14169 14170 case "meshOwner": 14171 if value != nil { 14172 jtv, ok := value.(string) 14173 if !ok { 14174 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14175 } 14176 sv.MeshOwner = ptr.String(jtv) 14177 } 14178 14179 case "resourceOwner": 14180 if value != nil { 14181 jtv, ok := value.(string) 14182 if !ok { 14183 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14184 } 14185 sv.ResourceOwner = ptr.String(jtv) 14186 } 14187 14188 case "version": 14189 if value != nil { 14190 jtv, ok := value.(json.Number) 14191 if !ok { 14192 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 14193 } 14194 i64, err := jtv.Int64() 14195 if err != nil { 14196 return err 14197 } 14198 sv.Version = ptr.Int64(i64) 14199 } 14200 14201 case "virtualNodeName": 14202 if value != nil { 14203 jtv, ok := value.(string) 14204 if !ok { 14205 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14206 } 14207 sv.VirtualNodeName = ptr.String(jtv) 14208 } 14209 14210 default: 14211 _, _ = key, value 14212 14213 } 14214 } 14215 *v = sv 14216 return nil 14217} 14218 14219func awsRestjson1_deserializeDocumentVirtualNodeServiceProvider(v **types.VirtualNodeServiceProvider, value interface{}) error { 14220 if v == nil { 14221 return fmt.Errorf("unexpected nil of type %T", v) 14222 } 14223 if value == nil { 14224 return nil 14225 } 14226 14227 shape, ok := value.(map[string]interface{}) 14228 if !ok { 14229 return fmt.Errorf("unexpected JSON type %v", value) 14230 } 14231 14232 var sv *types.VirtualNodeServiceProvider 14233 if *v == nil { 14234 sv = &types.VirtualNodeServiceProvider{} 14235 } else { 14236 sv = *v 14237 } 14238 14239 for key, value := range shape { 14240 switch key { 14241 case "virtualNodeName": 14242 if value != nil { 14243 jtv, ok := value.(string) 14244 if !ok { 14245 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14246 } 14247 sv.VirtualNodeName = ptr.String(jtv) 14248 } 14249 14250 default: 14251 _, _ = key, value 14252 14253 } 14254 } 14255 *v = sv 14256 return nil 14257} 14258 14259func awsRestjson1_deserializeDocumentVirtualNodeSpec(v **types.VirtualNodeSpec, value interface{}) error { 14260 if v == nil { 14261 return fmt.Errorf("unexpected nil of type %T", v) 14262 } 14263 if value == nil { 14264 return nil 14265 } 14266 14267 shape, ok := value.(map[string]interface{}) 14268 if !ok { 14269 return fmt.Errorf("unexpected JSON type %v", value) 14270 } 14271 14272 var sv *types.VirtualNodeSpec 14273 if *v == nil { 14274 sv = &types.VirtualNodeSpec{} 14275 } else { 14276 sv = *v 14277 } 14278 14279 for key, value := range shape { 14280 switch key { 14281 case "backendDefaults": 14282 if err := awsRestjson1_deserializeDocumentBackendDefaults(&sv.BackendDefaults, value); err != nil { 14283 return err 14284 } 14285 14286 case "backends": 14287 if err := awsRestjson1_deserializeDocumentBackends(&sv.Backends, value); err != nil { 14288 return err 14289 } 14290 14291 case "listeners": 14292 if err := awsRestjson1_deserializeDocumentListeners(&sv.Listeners, value); err != nil { 14293 return err 14294 } 14295 14296 case "logging": 14297 if err := awsRestjson1_deserializeDocumentLogging(&sv.Logging, value); err != nil { 14298 return err 14299 } 14300 14301 case "serviceDiscovery": 14302 if err := awsRestjson1_deserializeDocumentServiceDiscovery(&sv.ServiceDiscovery, value); err != nil { 14303 return err 14304 } 14305 14306 default: 14307 _, _ = key, value 14308 14309 } 14310 } 14311 *v = sv 14312 return nil 14313} 14314 14315func awsRestjson1_deserializeDocumentVirtualNodeStatus(v **types.VirtualNodeStatus, value interface{}) error { 14316 if v == nil { 14317 return fmt.Errorf("unexpected nil of type %T", v) 14318 } 14319 if value == nil { 14320 return nil 14321 } 14322 14323 shape, ok := value.(map[string]interface{}) 14324 if !ok { 14325 return fmt.Errorf("unexpected JSON type %v", value) 14326 } 14327 14328 var sv *types.VirtualNodeStatus 14329 if *v == nil { 14330 sv = &types.VirtualNodeStatus{} 14331 } else { 14332 sv = *v 14333 } 14334 14335 for key, value := range shape { 14336 switch key { 14337 case "status": 14338 if value != nil { 14339 jtv, ok := value.(string) 14340 if !ok { 14341 return fmt.Errorf("expected VirtualNodeStatusCode to be of type string, got %T instead", value) 14342 } 14343 sv.Status = types.VirtualNodeStatusCode(jtv) 14344 } 14345 14346 default: 14347 _, _ = key, value 14348 14349 } 14350 } 14351 *v = sv 14352 return nil 14353} 14354 14355func awsRestjson1_deserializeDocumentVirtualNodeTcpConnectionPool(v **types.VirtualNodeTcpConnectionPool, value interface{}) error { 14356 if v == nil { 14357 return fmt.Errorf("unexpected nil of type %T", v) 14358 } 14359 if value == nil { 14360 return nil 14361 } 14362 14363 shape, ok := value.(map[string]interface{}) 14364 if !ok { 14365 return fmt.Errorf("unexpected JSON type %v", value) 14366 } 14367 14368 var sv *types.VirtualNodeTcpConnectionPool 14369 if *v == nil { 14370 sv = &types.VirtualNodeTcpConnectionPool{} 14371 } else { 14372 sv = *v 14373 } 14374 14375 for key, value := range shape { 14376 switch key { 14377 case "maxConnections": 14378 if value != nil { 14379 jtv, ok := value.(json.Number) 14380 if !ok { 14381 return fmt.Errorf("expected MaxConnections to be json.Number, got %T instead", value) 14382 } 14383 i64, err := jtv.Int64() 14384 if err != nil { 14385 return err 14386 } 14387 sv.MaxConnections = int32(i64) 14388 } 14389 14390 default: 14391 _, _ = key, value 14392 14393 } 14394 } 14395 *v = sv 14396 return nil 14397} 14398 14399func awsRestjson1_deserializeDocumentVirtualRouterData(v **types.VirtualRouterData, value interface{}) error { 14400 if v == nil { 14401 return fmt.Errorf("unexpected nil of type %T", v) 14402 } 14403 if value == nil { 14404 return nil 14405 } 14406 14407 shape, ok := value.(map[string]interface{}) 14408 if !ok { 14409 return fmt.Errorf("unexpected JSON type %v", value) 14410 } 14411 14412 var sv *types.VirtualRouterData 14413 if *v == nil { 14414 sv = &types.VirtualRouterData{} 14415 } else { 14416 sv = *v 14417 } 14418 14419 for key, value := range shape { 14420 switch key { 14421 case "meshName": 14422 if value != nil { 14423 jtv, ok := value.(string) 14424 if !ok { 14425 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14426 } 14427 sv.MeshName = ptr.String(jtv) 14428 } 14429 14430 case "metadata": 14431 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 14432 return err 14433 } 14434 14435 case "spec": 14436 if err := awsRestjson1_deserializeDocumentVirtualRouterSpec(&sv.Spec, value); err != nil { 14437 return err 14438 } 14439 14440 case "status": 14441 if err := awsRestjson1_deserializeDocumentVirtualRouterStatus(&sv.Status, value); err != nil { 14442 return err 14443 } 14444 14445 case "virtualRouterName": 14446 if value != nil { 14447 jtv, ok := value.(string) 14448 if !ok { 14449 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14450 } 14451 sv.VirtualRouterName = ptr.String(jtv) 14452 } 14453 14454 default: 14455 _, _ = key, value 14456 14457 } 14458 } 14459 *v = sv 14460 return nil 14461} 14462 14463func awsRestjson1_deserializeDocumentVirtualRouterList(v *[]types.VirtualRouterRef, value interface{}) error { 14464 if v == nil { 14465 return fmt.Errorf("unexpected nil of type %T", v) 14466 } 14467 if value == nil { 14468 return nil 14469 } 14470 14471 shape, ok := value.([]interface{}) 14472 if !ok { 14473 return fmt.Errorf("unexpected JSON type %v", value) 14474 } 14475 14476 var cv []types.VirtualRouterRef 14477 if *v == nil { 14478 cv = []types.VirtualRouterRef{} 14479 } else { 14480 cv = *v 14481 } 14482 14483 for _, value := range shape { 14484 var col types.VirtualRouterRef 14485 destAddr := &col 14486 if err := awsRestjson1_deserializeDocumentVirtualRouterRef(&destAddr, value); err != nil { 14487 return err 14488 } 14489 col = *destAddr 14490 cv = append(cv, col) 14491 14492 } 14493 *v = cv 14494 return nil 14495} 14496 14497func awsRestjson1_deserializeDocumentVirtualRouterListener(v **types.VirtualRouterListener, value interface{}) error { 14498 if v == nil { 14499 return fmt.Errorf("unexpected nil of type %T", v) 14500 } 14501 if value == nil { 14502 return nil 14503 } 14504 14505 shape, ok := value.(map[string]interface{}) 14506 if !ok { 14507 return fmt.Errorf("unexpected JSON type %v", value) 14508 } 14509 14510 var sv *types.VirtualRouterListener 14511 if *v == nil { 14512 sv = &types.VirtualRouterListener{} 14513 } else { 14514 sv = *v 14515 } 14516 14517 for key, value := range shape { 14518 switch key { 14519 case "portMapping": 14520 if err := awsRestjson1_deserializeDocumentPortMapping(&sv.PortMapping, value); err != nil { 14521 return err 14522 } 14523 14524 default: 14525 _, _ = key, value 14526 14527 } 14528 } 14529 *v = sv 14530 return nil 14531} 14532 14533func awsRestjson1_deserializeDocumentVirtualRouterListeners(v *[]types.VirtualRouterListener, value interface{}) error { 14534 if v == nil { 14535 return fmt.Errorf("unexpected nil of type %T", v) 14536 } 14537 if value == nil { 14538 return nil 14539 } 14540 14541 shape, ok := value.([]interface{}) 14542 if !ok { 14543 return fmt.Errorf("unexpected JSON type %v", value) 14544 } 14545 14546 var cv []types.VirtualRouterListener 14547 if *v == nil { 14548 cv = []types.VirtualRouterListener{} 14549 } else { 14550 cv = *v 14551 } 14552 14553 for _, value := range shape { 14554 var col types.VirtualRouterListener 14555 destAddr := &col 14556 if err := awsRestjson1_deserializeDocumentVirtualRouterListener(&destAddr, value); err != nil { 14557 return err 14558 } 14559 col = *destAddr 14560 cv = append(cv, col) 14561 14562 } 14563 *v = cv 14564 return nil 14565} 14566 14567func awsRestjson1_deserializeDocumentVirtualRouterRef(v **types.VirtualRouterRef, value interface{}) error { 14568 if v == nil { 14569 return fmt.Errorf("unexpected nil of type %T", v) 14570 } 14571 if value == nil { 14572 return nil 14573 } 14574 14575 shape, ok := value.(map[string]interface{}) 14576 if !ok { 14577 return fmt.Errorf("unexpected JSON type %v", value) 14578 } 14579 14580 var sv *types.VirtualRouterRef 14581 if *v == nil { 14582 sv = &types.VirtualRouterRef{} 14583 } else { 14584 sv = *v 14585 } 14586 14587 for key, value := range shape { 14588 switch key { 14589 case "arn": 14590 if value != nil { 14591 jtv, ok := value.(string) 14592 if !ok { 14593 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 14594 } 14595 sv.Arn = ptr.String(jtv) 14596 } 14597 14598 case "createdAt": 14599 if value != nil { 14600 switch jtv := value.(type) { 14601 case json.Number: 14602 f64, err := jtv.Float64() 14603 if err != nil { 14604 return err 14605 } 14606 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14607 14608 default: 14609 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 14610 14611 } 14612 } 14613 14614 case "lastUpdatedAt": 14615 if value != nil { 14616 switch jtv := value.(type) { 14617 case json.Number: 14618 f64, err := jtv.Float64() 14619 if err != nil { 14620 return err 14621 } 14622 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14623 14624 default: 14625 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 14626 14627 } 14628 } 14629 14630 case "meshName": 14631 if value != nil { 14632 jtv, ok := value.(string) 14633 if !ok { 14634 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14635 } 14636 sv.MeshName = ptr.String(jtv) 14637 } 14638 14639 case "meshOwner": 14640 if value != nil { 14641 jtv, ok := value.(string) 14642 if !ok { 14643 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14644 } 14645 sv.MeshOwner = ptr.String(jtv) 14646 } 14647 14648 case "resourceOwner": 14649 if value != nil { 14650 jtv, ok := value.(string) 14651 if !ok { 14652 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14653 } 14654 sv.ResourceOwner = ptr.String(jtv) 14655 } 14656 14657 case "version": 14658 if value != nil { 14659 jtv, ok := value.(json.Number) 14660 if !ok { 14661 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 14662 } 14663 i64, err := jtv.Int64() 14664 if err != nil { 14665 return err 14666 } 14667 sv.Version = ptr.Int64(i64) 14668 } 14669 14670 case "virtualRouterName": 14671 if value != nil { 14672 jtv, ok := value.(string) 14673 if !ok { 14674 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14675 } 14676 sv.VirtualRouterName = ptr.String(jtv) 14677 } 14678 14679 default: 14680 _, _ = key, value 14681 14682 } 14683 } 14684 *v = sv 14685 return nil 14686} 14687 14688func awsRestjson1_deserializeDocumentVirtualRouterServiceProvider(v **types.VirtualRouterServiceProvider, value interface{}) error { 14689 if v == nil { 14690 return fmt.Errorf("unexpected nil of type %T", v) 14691 } 14692 if value == nil { 14693 return nil 14694 } 14695 14696 shape, ok := value.(map[string]interface{}) 14697 if !ok { 14698 return fmt.Errorf("unexpected JSON type %v", value) 14699 } 14700 14701 var sv *types.VirtualRouterServiceProvider 14702 if *v == nil { 14703 sv = &types.VirtualRouterServiceProvider{} 14704 } else { 14705 sv = *v 14706 } 14707 14708 for key, value := range shape { 14709 switch key { 14710 case "virtualRouterName": 14711 if value != nil { 14712 jtv, ok := value.(string) 14713 if !ok { 14714 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14715 } 14716 sv.VirtualRouterName = ptr.String(jtv) 14717 } 14718 14719 default: 14720 _, _ = key, value 14721 14722 } 14723 } 14724 *v = sv 14725 return nil 14726} 14727 14728func awsRestjson1_deserializeDocumentVirtualRouterSpec(v **types.VirtualRouterSpec, value interface{}) error { 14729 if v == nil { 14730 return fmt.Errorf("unexpected nil of type %T", v) 14731 } 14732 if value == nil { 14733 return nil 14734 } 14735 14736 shape, ok := value.(map[string]interface{}) 14737 if !ok { 14738 return fmt.Errorf("unexpected JSON type %v", value) 14739 } 14740 14741 var sv *types.VirtualRouterSpec 14742 if *v == nil { 14743 sv = &types.VirtualRouterSpec{} 14744 } else { 14745 sv = *v 14746 } 14747 14748 for key, value := range shape { 14749 switch key { 14750 case "listeners": 14751 if err := awsRestjson1_deserializeDocumentVirtualRouterListeners(&sv.Listeners, value); err != nil { 14752 return err 14753 } 14754 14755 default: 14756 _, _ = key, value 14757 14758 } 14759 } 14760 *v = sv 14761 return nil 14762} 14763 14764func awsRestjson1_deserializeDocumentVirtualRouterStatus(v **types.VirtualRouterStatus, value interface{}) error { 14765 if v == nil { 14766 return fmt.Errorf("unexpected nil of type %T", v) 14767 } 14768 if value == nil { 14769 return nil 14770 } 14771 14772 shape, ok := value.(map[string]interface{}) 14773 if !ok { 14774 return fmt.Errorf("unexpected JSON type %v", value) 14775 } 14776 14777 var sv *types.VirtualRouterStatus 14778 if *v == nil { 14779 sv = &types.VirtualRouterStatus{} 14780 } else { 14781 sv = *v 14782 } 14783 14784 for key, value := range shape { 14785 switch key { 14786 case "status": 14787 if value != nil { 14788 jtv, ok := value.(string) 14789 if !ok { 14790 return fmt.Errorf("expected VirtualRouterStatusCode to be of type string, got %T instead", value) 14791 } 14792 sv.Status = types.VirtualRouterStatusCode(jtv) 14793 } 14794 14795 default: 14796 _, _ = key, value 14797 14798 } 14799 } 14800 *v = sv 14801 return nil 14802} 14803 14804func awsRestjson1_deserializeDocumentVirtualServiceBackend(v **types.VirtualServiceBackend, value interface{}) error { 14805 if v == nil { 14806 return fmt.Errorf("unexpected nil of type %T", v) 14807 } 14808 if value == nil { 14809 return nil 14810 } 14811 14812 shape, ok := value.(map[string]interface{}) 14813 if !ok { 14814 return fmt.Errorf("unexpected JSON type %v", value) 14815 } 14816 14817 var sv *types.VirtualServiceBackend 14818 if *v == nil { 14819 sv = &types.VirtualServiceBackend{} 14820 } else { 14821 sv = *v 14822 } 14823 14824 for key, value := range shape { 14825 switch key { 14826 case "clientPolicy": 14827 if err := awsRestjson1_deserializeDocumentClientPolicy(&sv.ClientPolicy, value); err != nil { 14828 return err 14829 } 14830 14831 case "virtualServiceName": 14832 if value != nil { 14833 jtv, ok := value.(string) 14834 if !ok { 14835 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 14836 } 14837 sv.VirtualServiceName = ptr.String(jtv) 14838 } 14839 14840 default: 14841 _, _ = key, value 14842 14843 } 14844 } 14845 *v = sv 14846 return nil 14847} 14848 14849func awsRestjson1_deserializeDocumentVirtualServiceData(v **types.VirtualServiceData, value interface{}) error { 14850 if v == nil { 14851 return fmt.Errorf("unexpected nil of type %T", v) 14852 } 14853 if value == nil { 14854 return nil 14855 } 14856 14857 shape, ok := value.(map[string]interface{}) 14858 if !ok { 14859 return fmt.Errorf("unexpected JSON type %v", value) 14860 } 14861 14862 var sv *types.VirtualServiceData 14863 if *v == nil { 14864 sv = &types.VirtualServiceData{} 14865 } else { 14866 sv = *v 14867 } 14868 14869 for key, value := range shape { 14870 switch key { 14871 case "meshName": 14872 if value != nil { 14873 jtv, ok := value.(string) 14874 if !ok { 14875 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 14876 } 14877 sv.MeshName = ptr.String(jtv) 14878 } 14879 14880 case "metadata": 14881 if err := awsRestjson1_deserializeDocumentResourceMetadata(&sv.Metadata, value); err != nil { 14882 return err 14883 } 14884 14885 case "spec": 14886 if err := awsRestjson1_deserializeDocumentVirtualServiceSpec(&sv.Spec, value); err != nil { 14887 return err 14888 } 14889 14890 case "status": 14891 if err := awsRestjson1_deserializeDocumentVirtualServiceStatus(&sv.Status, value); err != nil { 14892 return err 14893 } 14894 14895 case "virtualServiceName": 14896 if value != nil { 14897 jtv, ok := value.(string) 14898 if !ok { 14899 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 14900 } 14901 sv.VirtualServiceName = ptr.String(jtv) 14902 } 14903 14904 default: 14905 _, _ = key, value 14906 14907 } 14908 } 14909 *v = sv 14910 return nil 14911} 14912 14913func awsRestjson1_deserializeDocumentVirtualServiceList(v *[]types.VirtualServiceRef, value interface{}) error { 14914 if v == nil { 14915 return fmt.Errorf("unexpected nil of type %T", v) 14916 } 14917 if value == nil { 14918 return nil 14919 } 14920 14921 shape, ok := value.([]interface{}) 14922 if !ok { 14923 return fmt.Errorf("unexpected JSON type %v", value) 14924 } 14925 14926 var cv []types.VirtualServiceRef 14927 if *v == nil { 14928 cv = []types.VirtualServiceRef{} 14929 } else { 14930 cv = *v 14931 } 14932 14933 for _, value := range shape { 14934 var col types.VirtualServiceRef 14935 destAddr := &col 14936 if err := awsRestjson1_deserializeDocumentVirtualServiceRef(&destAddr, value); err != nil { 14937 return err 14938 } 14939 col = *destAddr 14940 cv = append(cv, col) 14941 14942 } 14943 *v = cv 14944 return nil 14945} 14946 14947func awsRestjson1_deserializeDocumentVirtualServiceProvider(v *types.VirtualServiceProvider, value interface{}) error { 14948 if v == nil { 14949 return fmt.Errorf("unexpected nil of type %T", v) 14950 } 14951 if value == nil { 14952 return nil 14953 } 14954 14955 shape, ok := value.(map[string]interface{}) 14956 if !ok { 14957 return fmt.Errorf("unexpected JSON type %v", value) 14958 } 14959 14960 var uv types.VirtualServiceProvider 14961loop: 14962 for key, value := range shape { 14963 if value == nil { 14964 continue 14965 } 14966 switch key { 14967 case "virtualNode": 14968 var mv types.VirtualNodeServiceProvider 14969 destAddr := &mv 14970 if err := awsRestjson1_deserializeDocumentVirtualNodeServiceProvider(&destAddr, value); err != nil { 14971 return err 14972 } 14973 mv = *destAddr 14974 uv = &types.VirtualServiceProviderMemberVirtualNode{Value: mv} 14975 break loop 14976 14977 case "virtualRouter": 14978 var mv types.VirtualRouterServiceProvider 14979 destAddr := &mv 14980 if err := awsRestjson1_deserializeDocumentVirtualRouterServiceProvider(&destAddr, value); err != nil { 14981 return err 14982 } 14983 mv = *destAddr 14984 uv = &types.VirtualServiceProviderMemberVirtualRouter{Value: mv} 14985 break loop 14986 14987 default: 14988 uv = &types.UnknownUnionMember{Tag: key} 14989 break loop 14990 14991 } 14992 } 14993 *v = uv 14994 return nil 14995} 14996 14997func awsRestjson1_deserializeDocumentVirtualServiceRef(v **types.VirtualServiceRef, value interface{}) error { 14998 if v == nil { 14999 return fmt.Errorf("unexpected nil of type %T", v) 15000 } 15001 if value == nil { 15002 return nil 15003 } 15004 15005 shape, ok := value.(map[string]interface{}) 15006 if !ok { 15007 return fmt.Errorf("unexpected JSON type %v", value) 15008 } 15009 15010 var sv *types.VirtualServiceRef 15011 if *v == nil { 15012 sv = &types.VirtualServiceRef{} 15013 } else { 15014 sv = *v 15015 } 15016 15017 for key, value := range shape { 15018 switch key { 15019 case "arn": 15020 if value != nil { 15021 jtv, ok := value.(string) 15022 if !ok { 15023 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 15024 } 15025 sv.Arn = ptr.String(jtv) 15026 } 15027 15028 case "createdAt": 15029 if value != nil { 15030 switch jtv := value.(type) { 15031 case json.Number: 15032 f64, err := jtv.Float64() 15033 if err != nil { 15034 return err 15035 } 15036 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15037 15038 default: 15039 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 15040 15041 } 15042 } 15043 15044 case "lastUpdatedAt": 15045 if value != nil { 15046 switch jtv := value.(type) { 15047 case json.Number: 15048 f64, err := jtv.Float64() 15049 if err != nil { 15050 return err 15051 } 15052 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15053 15054 default: 15055 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 15056 15057 } 15058 } 15059 15060 case "meshName": 15061 if value != nil { 15062 jtv, ok := value.(string) 15063 if !ok { 15064 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 15065 } 15066 sv.MeshName = ptr.String(jtv) 15067 } 15068 15069 case "meshOwner": 15070 if value != nil { 15071 jtv, ok := value.(string) 15072 if !ok { 15073 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15074 } 15075 sv.MeshOwner = ptr.String(jtv) 15076 } 15077 15078 case "resourceOwner": 15079 if value != nil { 15080 jtv, ok := value.(string) 15081 if !ok { 15082 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15083 } 15084 sv.ResourceOwner = ptr.String(jtv) 15085 } 15086 15087 case "version": 15088 if value != nil { 15089 jtv, ok := value.(json.Number) 15090 if !ok { 15091 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 15092 } 15093 i64, err := jtv.Int64() 15094 if err != nil { 15095 return err 15096 } 15097 sv.Version = ptr.Int64(i64) 15098 } 15099 15100 case "virtualServiceName": 15101 if value != nil { 15102 jtv, ok := value.(string) 15103 if !ok { 15104 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 15105 } 15106 sv.VirtualServiceName = ptr.String(jtv) 15107 } 15108 15109 default: 15110 _, _ = key, value 15111 15112 } 15113 } 15114 *v = sv 15115 return nil 15116} 15117 15118func awsRestjson1_deserializeDocumentVirtualServiceSpec(v **types.VirtualServiceSpec, value interface{}) error { 15119 if v == nil { 15120 return fmt.Errorf("unexpected nil of type %T", v) 15121 } 15122 if value == nil { 15123 return nil 15124 } 15125 15126 shape, ok := value.(map[string]interface{}) 15127 if !ok { 15128 return fmt.Errorf("unexpected JSON type %v", value) 15129 } 15130 15131 var sv *types.VirtualServiceSpec 15132 if *v == nil { 15133 sv = &types.VirtualServiceSpec{} 15134 } else { 15135 sv = *v 15136 } 15137 15138 for key, value := range shape { 15139 switch key { 15140 case "provider": 15141 if err := awsRestjson1_deserializeDocumentVirtualServiceProvider(&sv.Provider, value); err != nil { 15142 return err 15143 } 15144 15145 default: 15146 _, _ = key, value 15147 15148 } 15149 } 15150 *v = sv 15151 return nil 15152} 15153 15154func awsRestjson1_deserializeDocumentVirtualServiceStatus(v **types.VirtualServiceStatus, value interface{}) error { 15155 if v == nil { 15156 return fmt.Errorf("unexpected nil of type %T", v) 15157 } 15158 if value == nil { 15159 return nil 15160 } 15161 15162 shape, ok := value.(map[string]interface{}) 15163 if !ok { 15164 return fmt.Errorf("unexpected JSON type %v", value) 15165 } 15166 15167 var sv *types.VirtualServiceStatus 15168 if *v == nil { 15169 sv = &types.VirtualServiceStatus{} 15170 } else { 15171 sv = *v 15172 } 15173 15174 for key, value := range shape { 15175 switch key { 15176 case "status": 15177 if value != nil { 15178 jtv, ok := value.(string) 15179 if !ok { 15180 return fmt.Errorf("expected VirtualServiceStatusCode to be of type string, got %T instead", value) 15181 } 15182 sv.Status = types.VirtualServiceStatusCode(jtv) 15183 } 15184 15185 default: 15186 _, _ = key, value 15187 15188 } 15189 } 15190 *v = sv 15191 return nil 15192} 15193 15194func awsRestjson1_deserializeDocumentWeightedTarget(v **types.WeightedTarget, value interface{}) error { 15195 if v == nil { 15196 return fmt.Errorf("unexpected nil of type %T", v) 15197 } 15198 if value == nil { 15199 return nil 15200 } 15201 15202 shape, ok := value.(map[string]interface{}) 15203 if !ok { 15204 return fmt.Errorf("unexpected JSON type %v", value) 15205 } 15206 15207 var sv *types.WeightedTarget 15208 if *v == nil { 15209 sv = &types.WeightedTarget{} 15210 } else { 15211 sv = *v 15212 } 15213 15214 for key, value := range shape { 15215 switch key { 15216 case "virtualNode": 15217 if value != nil { 15218 jtv, ok := value.(string) 15219 if !ok { 15220 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 15221 } 15222 sv.VirtualNode = ptr.String(jtv) 15223 } 15224 15225 case "weight": 15226 if value != nil { 15227 jtv, ok := value.(json.Number) 15228 if !ok { 15229 return fmt.Errorf("expected PercentInt to be json.Number, got %T instead", value) 15230 } 15231 i64, err := jtv.Int64() 15232 if err != nil { 15233 return err 15234 } 15235 sv.Weight = int32(i64) 15236 } 15237 15238 default: 15239 _, _ = key, value 15240 15241 } 15242 } 15243 *v = sv 15244 return nil 15245} 15246 15247func awsRestjson1_deserializeDocumentWeightedTargets(v *[]types.WeightedTarget, value interface{}) error { 15248 if v == nil { 15249 return fmt.Errorf("unexpected nil of type %T", v) 15250 } 15251 if value == nil { 15252 return nil 15253 } 15254 15255 shape, ok := value.([]interface{}) 15256 if !ok { 15257 return fmt.Errorf("unexpected JSON type %v", value) 15258 } 15259 15260 var cv []types.WeightedTarget 15261 if *v == nil { 15262 cv = []types.WeightedTarget{} 15263 } else { 15264 cv = *v 15265 } 15266 15267 for _, value := range shape { 15268 var col types.WeightedTarget 15269 destAddr := &col 15270 if err := awsRestjson1_deserializeDocumentWeightedTarget(&destAddr, value); err != nil { 15271 return err 15272 } 15273 col = *destAddr 15274 cv = append(cv, col) 15275 15276 } 15277 *v = cv 15278 return nil 15279} 15280