1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package globalaccelerator 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/globalaccelerator/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 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpAddCustomRoutingEndpoints struct { 24} 25 26func (*awsAwsjson11_deserializeOpAddCustomRoutingEndpoints) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpAddCustomRoutingEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsAwsjson11_deserializeOpErrorAddCustomRoutingEndpoints(response, &metadata) 45 } 46 output := &AddCustomRoutingEndpointsOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 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 = awsAwsjson11_deserializeOpDocumentAddCustomRoutingEndpointsOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_deserializeOpErrorAddCustomRoutingEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("AccessDeniedException", errorCode): 122 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 123 124 case strings.EqualFold("ConflictException", errorCode): 125 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 126 127 case strings.EqualFold("EndpointAlreadyExistsException", errorCode): 128 return awsAwsjson11_deserializeErrorEndpointAlreadyExistsException(response, errorBody) 129 130 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 131 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 132 133 case strings.EqualFold("InternalServiceErrorException", errorCode): 134 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 135 136 case strings.EqualFold("InvalidArgumentException", errorCode): 137 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 138 139 case strings.EqualFold("LimitExceededException", errorCode): 140 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 141 142 default: 143 genericError := &smithy.GenericAPIError{ 144 Code: errorCode, 145 Message: errorMessage, 146 } 147 return genericError 148 149 } 150} 151 152type awsAwsjson11_deserializeOpAdvertiseByoipCidr struct { 153} 154 155func (*awsAwsjson11_deserializeOpAdvertiseByoipCidr) ID() string { 156 return "OperationDeserializer" 157} 158 159func (m *awsAwsjson11_deserializeOpAdvertiseByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 160 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 161) { 162 out, metadata, err = next.HandleDeserialize(ctx, in) 163 if err != nil { 164 return out, metadata, err 165 } 166 167 response, ok := out.RawResponse.(*smithyhttp.Response) 168 if !ok { 169 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 170 } 171 172 if response.StatusCode < 200 || response.StatusCode >= 300 { 173 return out, metadata, awsAwsjson11_deserializeOpErrorAdvertiseByoipCidr(response, &metadata) 174 } 175 output := &AdvertiseByoipCidrOutput{} 176 out.Result = output 177 178 var buff [1024]byte 179 ringBuffer := smithyio.NewRingBuffer(buff[:]) 180 181 body := io.TeeReader(response.Body, ringBuffer) 182 decoder := json.NewDecoder(body) 183 decoder.UseNumber() 184 var shape interface{} 185 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 186 var snapshot bytes.Buffer 187 io.Copy(&snapshot, ringBuffer) 188 err = &smithy.DeserializationError{ 189 Err: fmt.Errorf("failed to decode response body, %w", err), 190 Snapshot: snapshot.Bytes(), 191 } 192 return out, metadata, err 193 } 194 195 err = awsAwsjson11_deserializeOpDocumentAdvertiseByoipCidrOutput(&output, shape) 196 if err != nil { 197 var snapshot bytes.Buffer 198 io.Copy(&snapshot, ringBuffer) 199 err = &smithy.DeserializationError{ 200 Err: fmt.Errorf("failed to decode response body, %w", err), 201 Snapshot: snapshot.Bytes(), 202 } 203 return out, metadata, err 204 } 205 206 return out, metadata, err 207} 208 209func awsAwsjson11_deserializeOpErrorAdvertiseByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { 210 var errorBuffer bytes.Buffer 211 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 212 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 213 } 214 errorBody := bytes.NewReader(errorBuffer.Bytes()) 215 216 errorCode := "UnknownError" 217 errorMessage := errorCode 218 219 code := response.Header.Get("X-Amzn-ErrorType") 220 if len(code) != 0 { 221 errorCode = restjson.SanitizeErrorCode(code) 222 } 223 224 var buff [1024]byte 225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 226 227 body := io.TeeReader(errorBody, ringBuffer) 228 decoder := json.NewDecoder(body) 229 decoder.UseNumber() 230 code, message, err := restjson.GetErrorInfo(decoder) 231 if err != nil { 232 var snapshot bytes.Buffer 233 io.Copy(&snapshot, ringBuffer) 234 err = &smithy.DeserializationError{ 235 Err: fmt.Errorf("failed to decode response body, %w", err), 236 Snapshot: snapshot.Bytes(), 237 } 238 return err 239 } 240 241 errorBody.Seek(0, io.SeekStart) 242 if len(code) != 0 { 243 errorCode = restjson.SanitizeErrorCode(code) 244 } 245 if len(message) != 0 { 246 errorMessage = message 247 } 248 249 switch { 250 case strings.EqualFold("AccessDeniedException", errorCode): 251 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 252 253 case strings.EqualFold("ByoipCidrNotFoundException", errorCode): 254 return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody) 255 256 case strings.EqualFold("IncorrectCidrStateException", errorCode): 257 return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody) 258 259 case strings.EqualFold("InternalServiceErrorException", errorCode): 260 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 261 262 case strings.EqualFold("InvalidArgumentException", errorCode): 263 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 264 265 default: 266 genericError := &smithy.GenericAPIError{ 267 Code: errorCode, 268 Message: errorMessage, 269 } 270 return genericError 271 272 } 273} 274 275type awsAwsjson11_deserializeOpAllowCustomRoutingTraffic struct { 276} 277 278func (*awsAwsjson11_deserializeOpAllowCustomRoutingTraffic) ID() string { 279 return "OperationDeserializer" 280} 281 282func (m *awsAwsjson11_deserializeOpAllowCustomRoutingTraffic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 283 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 284) { 285 out, metadata, err = next.HandleDeserialize(ctx, in) 286 if err != nil { 287 return out, metadata, err 288 } 289 290 response, ok := out.RawResponse.(*smithyhttp.Response) 291 if !ok { 292 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 293 } 294 295 if response.StatusCode < 200 || response.StatusCode >= 300 { 296 return out, metadata, awsAwsjson11_deserializeOpErrorAllowCustomRoutingTraffic(response, &metadata) 297 } 298 output := &AllowCustomRoutingTrafficOutput{} 299 out.Result = output 300 301 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 302 return out, metadata, &smithy.DeserializationError{ 303 Err: fmt.Errorf("failed to discard response body, %w", err), 304 } 305 } 306 307 return out, metadata, err 308} 309 310func awsAwsjson11_deserializeOpErrorAllowCustomRoutingTraffic(response *smithyhttp.Response, metadata *middleware.Metadata) error { 311 var errorBuffer bytes.Buffer 312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 314 } 315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 316 317 errorCode := "UnknownError" 318 errorMessage := errorCode 319 320 code := response.Header.Get("X-Amzn-ErrorType") 321 if len(code) != 0 { 322 errorCode = restjson.SanitizeErrorCode(code) 323 } 324 325 var buff [1024]byte 326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 327 328 body := io.TeeReader(errorBody, ringBuffer) 329 decoder := json.NewDecoder(body) 330 decoder.UseNumber() 331 code, message, err := restjson.GetErrorInfo(decoder) 332 if err != nil { 333 var snapshot bytes.Buffer 334 io.Copy(&snapshot, ringBuffer) 335 err = &smithy.DeserializationError{ 336 Err: fmt.Errorf("failed to decode response body, %w", err), 337 Snapshot: snapshot.Bytes(), 338 } 339 return err 340 } 341 342 errorBody.Seek(0, io.SeekStart) 343 if len(code) != 0 { 344 errorCode = restjson.SanitizeErrorCode(code) 345 } 346 if len(message) != 0 { 347 errorMessage = message 348 } 349 350 switch { 351 case strings.EqualFold("InternalServiceErrorException", errorCode): 352 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 353 354 case strings.EqualFold("InvalidArgumentException", errorCode): 355 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 356 357 default: 358 genericError := &smithy.GenericAPIError{ 359 Code: errorCode, 360 Message: errorMessage, 361 } 362 return genericError 363 364 } 365} 366 367type awsAwsjson11_deserializeOpCreateAccelerator struct { 368} 369 370func (*awsAwsjson11_deserializeOpCreateAccelerator) ID() string { 371 return "OperationDeserializer" 372} 373 374func (m *awsAwsjson11_deserializeOpCreateAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 375 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 376) { 377 out, metadata, err = next.HandleDeserialize(ctx, in) 378 if err != nil { 379 return out, metadata, err 380 } 381 382 response, ok := out.RawResponse.(*smithyhttp.Response) 383 if !ok { 384 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 385 } 386 387 if response.StatusCode < 200 || response.StatusCode >= 300 { 388 return out, metadata, awsAwsjson11_deserializeOpErrorCreateAccelerator(response, &metadata) 389 } 390 output := &CreateAcceleratorOutput{} 391 out.Result = output 392 393 var buff [1024]byte 394 ringBuffer := smithyio.NewRingBuffer(buff[:]) 395 396 body := io.TeeReader(response.Body, ringBuffer) 397 decoder := json.NewDecoder(body) 398 decoder.UseNumber() 399 var shape interface{} 400 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 401 var snapshot bytes.Buffer 402 io.Copy(&snapshot, ringBuffer) 403 err = &smithy.DeserializationError{ 404 Err: fmt.Errorf("failed to decode response body, %w", err), 405 Snapshot: snapshot.Bytes(), 406 } 407 return out, metadata, err 408 } 409 410 err = awsAwsjson11_deserializeOpDocumentCreateAcceleratorOutput(&output, shape) 411 if err != nil { 412 var snapshot bytes.Buffer 413 io.Copy(&snapshot, ringBuffer) 414 err = &smithy.DeserializationError{ 415 Err: fmt.Errorf("failed to decode response body, %w", err), 416 Snapshot: snapshot.Bytes(), 417 } 418 return out, metadata, err 419 } 420 421 return out, metadata, err 422} 423 424func awsAwsjson11_deserializeOpErrorCreateAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 425 var errorBuffer bytes.Buffer 426 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 427 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 428 } 429 errorBody := bytes.NewReader(errorBuffer.Bytes()) 430 431 errorCode := "UnknownError" 432 errorMessage := errorCode 433 434 code := response.Header.Get("X-Amzn-ErrorType") 435 if len(code) != 0 { 436 errorCode = restjson.SanitizeErrorCode(code) 437 } 438 439 var buff [1024]byte 440 ringBuffer := smithyio.NewRingBuffer(buff[:]) 441 442 body := io.TeeReader(errorBody, ringBuffer) 443 decoder := json.NewDecoder(body) 444 decoder.UseNumber() 445 code, message, err := restjson.GetErrorInfo(decoder) 446 if err != nil { 447 var snapshot bytes.Buffer 448 io.Copy(&snapshot, ringBuffer) 449 err = &smithy.DeserializationError{ 450 Err: fmt.Errorf("failed to decode response body, %w", err), 451 Snapshot: snapshot.Bytes(), 452 } 453 return err 454 } 455 456 errorBody.Seek(0, io.SeekStart) 457 if len(code) != 0 { 458 errorCode = restjson.SanitizeErrorCode(code) 459 } 460 if len(message) != 0 { 461 errorMessage = message 462 } 463 464 switch { 465 case strings.EqualFold("InternalServiceErrorException", errorCode): 466 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 467 468 case strings.EqualFold("InvalidArgumentException", errorCode): 469 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 470 471 case strings.EqualFold("LimitExceededException", errorCode): 472 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 473 474 default: 475 genericError := &smithy.GenericAPIError{ 476 Code: errorCode, 477 Message: errorMessage, 478 } 479 return genericError 480 481 } 482} 483 484type awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator struct { 485} 486 487func (*awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator) ID() string { 488 return "OperationDeserializer" 489} 490 491func (m *awsAwsjson11_deserializeOpCreateCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 492 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 493) { 494 out, metadata, err = next.HandleDeserialize(ctx, in) 495 if err != nil { 496 return out, metadata, err 497 } 498 499 response, ok := out.RawResponse.(*smithyhttp.Response) 500 if !ok { 501 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 502 } 503 504 if response.StatusCode < 200 || response.StatusCode >= 300 { 505 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingAccelerator(response, &metadata) 506 } 507 output := &CreateCustomRoutingAcceleratorOutput{} 508 out.Result = output 509 510 var buff [1024]byte 511 ringBuffer := smithyio.NewRingBuffer(buff[:]) 512 513 body := io.TeeReader(response.Body, ringBuffer) 514 decoder := json.NewDecoder(body) 515 decoder.UseNumber() 516 var shape interface{} 517 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 518 var snapshot bytes.Buffer 519 io.Copy(&snapshot, ringBuffer) 520 err = &smithy.DeserializationError{ 521 Err: fmt.Errorf("failed to decode response body, %w", err), 522 Snapshot: snapshot.Bytes(), 523 } 524 return out, metadata, err 525 } 526 527 err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingAcceleratorOutput(&output, shape) 528 if err != nil { 529 var snapshot bytes.Buffer 530 io.Copy(&snapshot, ringBuffer) 531 err = &smithy.DeserializationError{ 532 Err: fmt.Errorf("failed to decode response body, %w", err), 533 Snapshot: snapshot.Bytes(), 534 } 535 return out, metadata, err 536 } 537 538 return out, metadata, err 539} 540 541func awsAwsjson11_deserializeOpErrorCreateCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 542 var errorBuffer bytes.Buffer 543 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 544 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 545 } 546 errorBody := bytes.NewReader(errorBuffer.Bytes()) 547 548 errorCode := "UnknownError" 549 errorMessage := errorCode 550 551 code := response.Header.Get("X-Amzn-ErrorType") 552 if len(code) != 0 { 553 errorCode = restjson.SanitizeErrorCode(code) 554 } 555 556 var buff [1024]byte 557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 558 559 body := io.TeeReader(errorBody, ringBuffer) 560 decoder := json.NewDecoder(body) 561 decoder.UseNumber() 562 code, message, err := restjson.GetErrorInfo(decoder) 563 if err != nil { 564 var snapshot bytes.Buffer 565 io.Copy(&snapshot, ringBuffer) 566 err = &smithy.DeserializationError{ 567 Err: fmt.Errorf("failed to decode response body, %w", err), 568 Snapshot: snapshot.Bytes(), 569 } 570 return err 571 } 572 573 errorBody.Seek(0, io.SeekStart) 574 if len(code) != 0 { 575 errorCode = restjson.SanitizeErrorCode(code) 576 } 577 if len(message) != 0 { 578 errorMessage = message 579 } 580 581 switch { 582 case strings.EqualFold("AccessDeniedException", errorCode): 583 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 584 585 case strings.EqualFold("InternalServiceErrorException", errorCode): 586 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 587 588 case strings.EqualFold("InvalidArgumentException", errorCode): 589 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 590 591 case strings.EqualFold("LimitExceededException", errorCode): 592 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 593 594 default: 595 genericError := &smithy.GenericAPIError{ 596 Code: errorCode, 597 Message: errorMessage, 598 } 599 return genericError 600 601 } 602} 603 604type awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup struct { 605} 606 607func (*awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup) ID() string { 608 return "OperationDeserializer" 609} 610 611func (m *awsAwsjson11_deserializeOpCreateCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 612 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 613) { 614 out, metadata, err = next.HandleDeserialize(ctx, in) 615 if err != nil { 616 return out, metadata, err 617 } 618 619 response, ok := out.RawResponse.(*smithyhttp.Response) 620 if !ok { 621 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 622 } 623 624 if response.StatusCode < 200 || response.StatusCode >= 300 { 625 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingEndpointGroup(response, &metadata) 626 } 627 output := &CreateCustomRoutingEndpointGroupOutput{} 628 out.Result = output 629 630 var buff [1024]byte 631 ringBuffer := smithyio.NewRingBuffer(buff[:]) 632 633 body := io.TeeReader(response.Body, ringBuffer) 634 decoder := json.NewDecoder(body) 635 decoder.UseNumber() 636 var shape interface{} 637 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 638 var snapshot bytes.Buffer 639 io.Copy(&snapshot, ringBuffer) 640 err = &smithy.DeserializationError{ 641 Err: fmt.Errorf("failed to decode response body, %w", err), 642 Snapshot: snapshot.Bytes(), 643 } 644 return out, metadata, err 645 } 646 647 err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingEndpointGroupOutput(&output, shape) 648 if err != nil { 649 var snapshot bytes.Buffer 650 io.Copy(&snapshot, ringBuffer) 651 err = &smithy.DeserializationError{ 652 Err: fmt.Errorf("failed to decode response body, %w", err), 653 Snapshot: snapshot.Bytes(), 654 } 655 return out, metadata, err 656 } 657 658 return out, metadata, err 659} 660 661func awsAwsjson11_deserializeOpErrorCreateCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 662 var errorBuffer bytes.Buffer 663 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 664 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 665 } 666 errorBody := bytes.NewReader(errorBuffer.Bytes()) 667 668 errorCode := "UnknownError" 669 errorMessage := errorCode 670 671 code := response.Header.Get("X-Amzn-ErrorType") 672 if len(code) != 0 { 673 errorCode = restjson.SanitizeErrorCode(code) 674 } 675 676 var buff [1024]byte 677 ringBuffer := smithyio.NewRingBuffer(buff[:]) 678 679 body := io.TeeReader(errorBody, ringBuffer) 680 decoder := json.NewDecoder(body) 681 decoder.UseNumber() 682 code, message, err := restjson.GetErrorInfo(decoder) 683 if err != nil { 684 var snapshot bytes.Buffer 685 io.Copy(&snapshot, ringBuffer) 686 err = &smithy.DeserializationError{ 687 Err: fmt.Errorf("failed to decode response body, %w", err), 688 Snapshot: snapshot.Bytes(), 689 } 690 return err 691 } 692 693 errorBody.Seek(0, io.SeekStart) 694 if len(code) != 0 { 695 errorCode = restjson.SanitizeErrorCode(code) 696 } 697 if len(message) != 0 { 698 errorMessage = message 699 } 700 701 switch { 702 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 703 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 704 705 case strings.EqualFold("AccessDeniedException", errorCode): 706 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 707 708 case strings.EqualFold("EndpointGroupAlreadyExistsException", errorCode): 709 return awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response, errorBody) 710 711 case strings.EqualFold("InternalServiceErrorException", errorCode): 712 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 713 714 case strings.EqualFold("InvalidArgumentException", errorCode): 715 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 716 717 case strings.EqualFold("InvalidPortRangeException", errorCode): 718 return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody) 719 720 case strings.EqualFold("LimitExceededException", errorCode): 721 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 722 723 case strings.EqualFold("ListenerNotFoundException", errorCode): 724 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 725 726 default: 727 genericError := &smithy.GenericAPIError{ 728 Code: errorCode, 729 Message: errorMessage, 730 } 731 return genericError 732 733 } 734} 735 736type awsAwsjson11_deserializeOpCreateCustomRoutingListener struct { 737} 738 739func (*awsAwsjson11_deserializeOpCreateCustomRoutingListener) ID() string { 740 return "OperationDeserializer" 741} 742 743func (m *awsAwsjson11_deserializeOpCreateCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 744 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 745) { 746 out, metadata, err = next.HandleDeserialize(ctx, in) 747 if err != nil { 748 return out, metadata, err 749 } 750 751 response, ok := out.RawResponse.(*smithyhttp.Response) 752 if !ok { 753 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 754 } 755 756 if response.StatusCode < 200 || response.StatusCode >= 300 { 757 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCustomRoutingListener(response, &metadata) 758 } 759 output := &CreateCustomRoutingListenerOutput{} 760 out.Result = output 761 762 var buff [1024]byte 763 ringBuffer := smithyio.NewRingBuffer(buff[:]) 764 765 body := io.TeeReader(response.Body, ringBuffer) 766 decoder := json.NewDecoder(body) 767 decoder.UseNumber() 768 var shape interface{} 769 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 770 var snapshot bytes.Buffer 771 io.Copy(&snapshot, ringBuffer) 772 err = &smithy.DeserializationError{ 773 Err: fmt.Errorf("failed to decode response body, %w", err), 774 Snapshot: snapshot.Bytes(), 775 } 776 return out, metadata, err 777 } 778 779 err = awsAwsjson11_deserializeOpDocumentCreateCustomRoutingListenerOutput(&output, shape) 780 if err != nil { 781 var snapshot bytes.Buffer 782 io.Copy(&snapshot, ringBuffer) 783 err = &smithy.DeserializationError{ 784 Err: fmt.Errorf("failed to decode response body, %w", err), 785 Snapshot: snapshot.Bytes(), 786 } 787 return out, metadata, err 788 } 789 790 return out, metadata, err 791} 792 793func awsAwsjson11_deserializeOpErrorCreateCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 794 var errorBuffer bytes.Buffer 795 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 796 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 797 } 798 errorBody := bytes.NewReader(errorBuffer.Bytes()) 799 800 errorCode := "UnknownError" 801 errorMessage := errorCode 802 803 code := response.Header.Get("X-Amzn-ErrorType") 804 if len(code) != 0 { 805 errorCode = restjson.SanitizeErrorCode(code) 806 } 807 808 var buff [1024]byte 809 ringBuffer := smithyio.NewRingBuffer(buff[:]) 810 811 body := io.TeeReader(errorBody, ringBuffer) 812 decoder := json.NewDecoder(body) 813 decoder.UseNumber() 814 code, message, err := restjson.GetErrorInfo(decoder) 815 if err != nil { 816 var snapshot bytes.Buffer 817 io.Copy(&snapshot, ringBuffer) 818 err = &smithy.DeserializationError{ 819 Err: fmt.Errorf("failed to decode response body, %w", err), 820 Snapshot: snapshot.Bytes(), 821 } 822 return err 823 } 824 825 errorBody.Seek(0, io.SeekStart) 826 if len(code) != 0 { 827 errorCode = restjson.SanitizeErrorCode(code) 828 } 829 if len(message) != 0 { 830 errorMessage = message 831 } 832 833 switch { 834 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 835 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 836 837 case strings.EqualFold("InternalServiceErrorException", errorCode): 838 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 839 840 case strings.EqualFold("InvalidArgumentException", errorCode): 841 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 842 843 case strings.EqualFold("InvalidPortRangeException", errorCode): 844 return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody) 845 846 case strings.EqualFold("LimitExceededException", errorCode): 847 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 848 849 default: 850 genericError := &smithy.GenericAPIError{ 851 Code: errorCode, 852 Message: errorMessage, 853 } 854 return genericError 855 856 } 857} 858 859type awsAwsjson11_deserializeOpCreateEndpointGroup struct { 860} 861 862func (*awsAwsjson11_deserializeOpCreateEndpointGroup) ID() string { 863 return "OperationDeserializer" 864} 865 866func (m *awsAwsjson11_deserializeOpCreateEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 867 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 868) { 869 out, metadata, err = next.HandleDeserialize(ctx, in) 870 if err != nil { 871 return out, metadata, err 872 } 873 874 response, ok := out.RawResponse.(*smithyhttp.Response) 875 if !ok { 876 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 877 } 878 879 if response.StatusCode < 200 || response.StatusCode >= 300 { 880 return out, metadata, awsAwsjson11_deserializeOpErrorCreateEndpointGroup(response, &metadata) 881 } 882 output := &CreateEndpointGroupOutput{} 883 out.Result = output 884 885 var buff [1024]byte 886 ringBuffer := smithyio.NewRingBuffer(buff[:]) 887 888 body := io.TeeReader(response.Body, ringBuffer) 889 decoder := json.NewDecoder(body) 890 decoder.UseNumber() 891 var shape interface{} 892 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 893 var snapshot bytes.Buffer 894 io.Copy(&snapshot, ringBuffer) 895 err = &smithy.DeserializationError{ 896 Err: fmt.Errorf("failed to decode response body, %w", err), 897 Snapshot: snapshot.Bytes(), 898 } 899 return out, metadata, err 900 } 901 902 err = awsAwsjson11_deserializeOpDocumentCreateEndpointGroupOutput(&output, shape) 903 if err != nil { 904 var snapshot bytes.Buffer 905 io.Copy(&snapshot, ringBuffer) 906 err = &smithy.DeserializationError{ 907 Err: fmt.Errorf("failed to decode response body, %w", err), 908 Snapshot: snapshot.Bytes(), 909 } 910 return out, metadata, err 911 } 912 913 return out, metadata, err 914} 915 916func awsAwsjson11_deserializeOpErrorCreateEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 917 var errorBuffer bytes.Buffer 918 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 919 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 920 } 921 errorBody := bytes.NewReader(errorBuffer.Bytes()) 922 923 errorCode := "UnknownError" 924 errorMessage := errorCode 925 926 code := response.Header.Get("X-Amzn-ErrorType") 927 if len(code) != 0 { 928 errorCode = restjson.SanitizeErrorCode(code) 929 } 930 931 var buff [1024]byte 932 ringBuffer := smithyio.NewRingBuffer(buff[:]) 933 934 body := io.TeeReader(errorBody, ringBuffer) 935 decoder := json.NewDecoder(body) 936 decoder.UseNumber() 937 code, message, err := restjson.GetErrorInfo(decoder) 938 if err != nil { 939 var snapshot bytes.Buffer 940 io.Copy(&snapshot, ringBuffer) 941 err = &smithy.DeserializationError{ 942 Err: fmt.Errorf("failed to decode response body, %w", err), 943 Snapshot: snapshot.Bytes(), 944 } 945 return err 946 } 947 948 errorBody.Seek(0, io.SeekStart) 949 if len(code) != 0 { 950 errorCode = restjson.SanitizeErrorCode(code) 951 } 952 if len(message) != 0 { 953 errorMessage = message 954 } 955 956 switch { 957 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 958 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 959 960 case strings.EqualFold("AccessDeniedException", errorCode): 961 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 962 963 case strings.EqualFold("EndpointGroupAlreadyExistsException", errorCode): 964 return awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response, errorBody) 965 966 case strings.EqualFold("InternalServiceErrorException", errorCode): 967 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 968 969 case strings.EqualFold("InvalidArgumentException", errorCode): 970 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 971 972 case strings.EqualFold("LimitExceededException", errorCode): 973 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 974 975 case strings.EqualFold("ListenerNotFoundException", errorCode): 976 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 977 978 default: 979 genericError := &smithy.GenericAPIError{ 980 Code: errorCode, 981 Message: errorMessage, 982 } 983 return genericError 984 985 } 986} 987 988type awsAwsjson11_deserializeOpCreateListener struct { 989} 990 991func (*awsAwsjson11_deserializeOpCreateListener) ID() string { 992 return "OperationDeserializer" 993} 994 995func (m *awsAwsjson11_deserializeOpCreateListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 996 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 997) { 998 out, metadata, err = next.HandleDeserialize(ctx, in) 999 if err != nil { 1000 return out, metadata, err 1001 } 1002 1003 response, ok := out.RawResponse.(*smithyhttp.Response) 1004 if !ok { 1005 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1006 } 1007 1008 if response.StatusCode < 200 || response.StatusCode >= 300 { 1009 return out, metadata, awsAwsjson11_deserializeOpErrorCreateListener(response, &metadata) 1010 } 1011 output := &CreateListenerOutput{} 1012 out.Result = output 1013 1014 var buff [1024]byte 1015 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1016 1017 body := io.TeeReader(response.Body, ringBuffer) 1018 decoder := json.NewDecoder(body) 1019 decoder.UseNumber() 1020 var shape interface{} 1021 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1022 var snapshot bytes.Buffer 1023 io.Copy(&snapshot, ringBuffer) 1024 err = &smithy.DeserializationError{ 1025 Err: fmt.Errorf("failed to decode response body, %w", err), 1026 Snapshot: snapshot.Bytes(), 1027 } 1028 return out, metadata, err 1029 } 1030 1031 err = awsAwsjson11_deserializeOpDocumentCreateListenerOutput(&output, shape) 1032 if err != nil { 1033 var snapshot bytes.Buffer 1034 io.Copy(&snapshot, ringBuffer) 1035 err = &smithy.DeserializationError{ 1036 Err: fmt.Errorf("failed to decode response body, %w", err), 1037 Snapshot: snapshot.Bytes(), 1038 } 1039 return out, metadata, err 1040 } 1041 1042 return out, metadata, err 1043} 1044 1045func awsAwsjson11_deserializeOpErrorCreateListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1046 var errorBuffer bytes.Buffer 1047 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1048 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1049 } 1050 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1051 1052 errorCode := "UnknownError" 1053 errorMessage := errorCode 1054 1055 code := response.Header.Get("X-Amzn-ErrorType") 1056 if len(code) != 0 { 1057 errorCode = restjson.SanitizeErrorCode(code) 1058 } 1059 1060 var buff [1024]byte 1061 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1062 1063 body := io.TeeReader(errorBody, ringBuffer) 1064 decoder := json.NewDecoder(body) 1065 decoder.UseNumber() 1066 code, message, err := restjson.GetErrorInfo(decoder) 1067 if err != nil { 1068 var snapshot bytes.Buffer 1069 io.Copy(&snapshot, ringBuffer) 1070 err = &smithy.DeserializationError{ 1071 Err: fmt.Errorf("failed to decode response body, %w", err), 1072 Snapshot: snapshot.Bytes(), 1073 } 1074 return err 1075 } 1076 1077 errorBody.Seek(0, io.SeekStart) 1078 if len(code) != 0 { 1079 errorCode = restjson.SanitizeErrorCode(code) 1080 } 1081 if len(message) != 0 { 1082 errorMessage = message 1083 } 1084 1085 switch { 1086 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 1087 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 1088 1089 case strings.EqualFold("InternalServiceErrorException", errorCode): 1090 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1091 1092 case strings.EqualFold("InvalidArgumentException", errorCode): 1093 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1094 1095 case strings.EqualFold("InvalidPortRangeException", errorCode): 1096 return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody) 1097 1098 case strings.EqualFold("LimitExceededException", errorCode): 1099 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1100 1101 default: 1102 genericError := &smithy.GenericAPIError{ 1103 Code: errorCode, 1104 Message: errorMessage, 1105 } 1106 return genericError 1107 1108 } 1109} 1110 1111type awsAwsjson11_deserializeOpDeleteAccelerator struct { 1112} 1113 1114func (*awsAwsjson11_deserializeOpDeleteAccelerator) ID() string { 1115 return "OperationDeserializer" 1116} 1117 1118func (m *awsAwsjson11_deserializeOpDeleteAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1119 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1120) { 1121 out, metadata, err = next.HandleDeserialize(ctx, in) 1122 if err != nil { 1123 return out, metadata, err 1124 } 1125 1126 response, ok := out.RawResponse.(*smithyhttp.Response) 1127 if !ok { 1128 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1129 } 1130 1131 if response.StatusCode < 200 || response.StatusCode >= 300 { 1132 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccelerator(response, &metadata) 1133 } 1134 output := &DeleteAcceleratorOutput{} 1135 out.Result = output 1136 1137 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1138 return out, metadata, &smithy.DeserializationError{ 1139 Err: fmt.Errorf("failed to discard response body, %w", err), 1140 } 1141 } 1142 1143 return out, metadata, err 1144} 1145 1146func awsAwsjson11_deserializeOpErrorDeleteAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1147 var errorBuffer bytes.Buffer 1148 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1149 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1150 } 1151 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1152 1153 errorCode := "UnknownError" 1154 errorMessage := errorCode 1155 1156 code := response.Header.Get("X-Amzn-ErrorType") 1157 if len(code) != 0 { 1158 errorCode = restjson.SanitizeErrorCode(code) 1159 } 1160 1161 var buff [1024]byte 1162 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1163 1164 body := io.TeeReader(errorBody, ringBuffer) 1165 decoder := json.NewDecoder(body) 1166 decoder.UseNumber() 1167 code, message, err := restjson.GetErrorInfo(decoder) 1168 if err != nil { 1169 var snapshot bytes.Buffer 1170 io.Copy(&snapshot, ringBuffer) 1171 err = &smithy.DeserializationError{ 1172 Err: fmt.Errorf("failed to decode response body, %w", err), 1173 Snapshot: snapshot.Bytes(), 1174 } 1175 return err 1176 } 1177 1178 errorBody.Seek(0, io.SeekStart) 1179 if len(code) != 0 { 1180 errorCode = restjson.SanitizeErrorCode(code) 1181 } 1182 if len(message) != 0 { 1183 errorMessage = message 1184 } 1185 1186 switch { 1187 case strings.EqualFold("AcceleratorNotDisabledException", errorCode): 1188 return awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response, errorBody) 1189 1190 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 1191 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 1192 1193 case strings.EqualFold("AssociatedListenerFoundException", errorCode): 1194 return awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response, errorBody) 1195 1196 case strings.EqualFold("InternalServiceErrorException", errorCode): 1197 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1198 1199 case strings.EqualFold("InvalidArgumentException", errorCode): 1200 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1201 1202 default: 1203 genericError := &smithy.GenericAPIError{ 1204 Code: errorCode, 1205 Message: errorMessage, 1206 } 1207 return genericError 1208 1209 } 1210} 1211 1212type awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator struct { 1213} 1214 1215func (*awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator) ID() string { 1216 return "OperationDeserializer" 1217} 1218 1219func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1220 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1221) { 1222 out, metadata, err = next.HandleDeserialize(ctx, in) 1223 if err != nil { 1224 return out, metadata, err 1225 } 1226 1227 response, ok := out.RawResponse.(*smithyhttp.Response) 1228 if !ok { 1229 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1230 } 1231 1232 if response.StatusCode < 200 || response.StatusCode >= 300 { 1233 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingAccelerator(response, &metadata) 1234 } 1235 output := &DeleteCustomRoutingAcceleratorOutput{} 1236 out.Result = output 1237 1238 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1239 return out, metadata, &smithy.DeserializationError{ 1240 Err: fmt.Errorf("failed to discard response body, %w", err), 1241 } 1242 } 1243 1244 return out, metadata, err 1245} 1246 1247func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1248 var errorBuffer bytes.Buffer 1249 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1250 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1251 } 1252 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1253 1254 errorCode := "UnknownError" 1255 errorMessage := errorCode 1256 1257 code := response.Header.Get("X-Amzn-ErrorType") 1258 if len(code) != 0 { 1259 errorCode = restjson.SanitizeErrorCode(code) 1260 } 1261 1262 var buff [1024]byte 1263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1264 1265 body := io.TeeReader(errorBody, ringBuffer) 1266 decoder := json.NewDecoder(body) 1267 decoder.UseNumber() 1268 code, message, err := restjson.GetErrorInfo(decoder) 1269 if err != nil { 1270 var snapshot bytes.Buffer 1271 io.Copy(&snapshot, ringBuffer) 1272 err = &smithy.DeserializationError{ 1273 Err: fmt.Errorf("failed to decode response body, %w", err), 1274 Snapshot: snapshot.Bytes(), 1275 } 1276 return err 1277 } 1278 1279 errorBody.Seek(0, io.SeekStart) 1280 if len(code) != 0 { 1281 errorCode = restjson.SanitizeErrorCode(code) 1282 } 1283 if len(message) != 0 { 1284 errorMessage = message 1285 } 1286 1287 switch { 1288 case strings.EqualFold("AcceleratorNotDisabledException", errorCode): 1289 return awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response, errorBody) 1290 1291 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 1292 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 1293 1294 case strings.EqualFold("AssociatedListenerFoundException", errorCode): 1295 return awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response, errorBody) 1296 1297 case strings.EqualFold("InternalServiceErrorException", errorCode): 1298 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1299 1300 case strings.EqualFold("InvalidArgumentException", errorCode): 1301 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1302 1303 default: 1304 genericError := &smithy.GenericAPIError{ 1305 Code: errorCode, 1306 Message: errorMessage, 1307 } 1308 return genericError 1309 1310 } 1311} 1312 1313type awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup struct { 1314} 1315 1316func (*awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup) ID() string { 1317 return "OperationDeserializer" 1318} 1319 1320func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1321 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1322) { 1323 out, metadata, err = next.HandleDeserialize(ctx, in) 1324 if err != nil { 1325 return out, metadata, err 1326 } 1327 1328 response, ok := out.RawResponse.(*smithyhttp.Response) 1329 if !ok { 1330 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1331 } 1332 1333 if response.StatusCode < 200 || response.StatusCode >= 300 { 1334 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingEndpointGroup(response, &metadata) 1335 } 1336 output := &DeleteCustomRoutingEndpointGroupOutput{} 1337 out.Result = output 1338 1339 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1340 return out, metadata, &smithy.DeserializationError{ 1341 Err: fmt.Errorf("failed to discard response body, %w", err), 1342 } 1343 } 1344 1345 return out, metadata, err 1346} 1347 1348func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1349 var errorBuffer bytes.Buffer 1350 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1351 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1352 } 1353 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1354 1355 errorCode := "UnknownError" 1356 errorMessage := errorCode 1357 1358 code := response.Header.Get("X-Amzn-ErrorType") 1359 if len(code) != 0 { 1360 errorCode = restjson.SanitizeErrorCode(code) 1361 } 1362 1363 var buff [1024]byte 1364 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1365 1366 body := io.TeeReader(errorBody, ringBuffer) 1367 decoder := json.NewDecoder(body) 1368 decoder.UseNumber() 1369 code, message, err := restjson.GetErrorInfo(decoder) 1370 if err != nil { 1371 var snapshot bytes.Buffer 1372 io.Copy(&snapshot, ringBuffer) 1373 err = &smithy.DeserializationError{ 1374 Err: fmt.Errorf("failed to decode response body, %w", err), 1375 Snapshot: snapshot.Bytes(), 1376 } 1377 return err 1378 } 1379 1380 errorBody.Seek(0, io.SeekStart) 1381 if len(code) != 0 { 1382 errorCode = restjson.SanitizeErrorCode(code) 1383 } 1384 if len(message) != 0 { 1385 errorMessage = message 1386 } 1387 1388 switch { 1389 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 1390 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 1391 1392 case strings.EqualFold("InternalServiceErrorException", errorCode): 1393 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1394 1395 case strings.EqualFold("InvalidArgumentException", errorCode): 1396 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1397 1398 default: 1399 genericError := &smithy.GenericAPIError{ 1400 Code: errorCode, 1401 Message: errorMessage, 1402 } 1403 return genericError 1404 1405 } 1406} 1407 1408type awsAwsjson11_deserializeOpDeleteCustomRoutingListener struct { 1409} 1410 1411func (*awsAwsjson11_deserializeOpDeleteCustomRoutingListener) ID() string { 1412 return "OperationDeserializer" 1413} 1414 1415func (m *awsAwsjson11_deserializeOpDeleteCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1416 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1417) { 1418 out, metadata, err = next.HandleDeserialize(ctx, in) 1419 if err != nil { 1420 return out, metadata, err 1421 } 1422 1423 response, ok := out.RawResponse.(*smithyhttp.Response) 1424 if !ok { 1425 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1426 } 1427 1428 if response.StatusCode < 200 || response.StatusCode >= 300 { 1429 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCustomRoutingListener(response, &metadata) 1430 } 1431 output := &DeleteCustomRoutingListenerOutput{} 1432 out.Result = output 1433 1434 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1435 return out, metadata, &smithy.DeserializationError{ 1436 Err: fmt.Errorf("failed to discard response body, %w", err), 1437 } 1438 } 1439 1440 return out, metadata, err 1441} 1442 1443func awsAwsjson11_deserializeOpErrorDeleteCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1444 var errorBuffer bytes.Buffer 1445 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1446 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1447 } 1448 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1449 1450 errorCode := "UnknownError" 1451 errorMessage := errorCode 1452 1453 code := response.Header.Get("X-Amzn-ErrorType") 1454 if len(code) != 0 { 1455 errorCode = restjson.SanitizeErrorCode(code) 1456 } 1457 1458 var buff [1024]byte 1459 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1460 1461 body := io.TeeReader(errorBody, ringBuffer) 1462 decoder := json.NewDecoder(body) 1463 decoder.UseNumber() 1464 code, message, err := restjson.GetErrorInfo(decoder) 1465 if err != nil { 1466 var snapshot bytes.Buffer 1467 io.Copy(&snapshot, ringBuffer) 1468 err = &smithy.DeserializationError{ 1469 Err: fmt.Errorf("failed to decode response body, %w", err), 1470 Snapshot: snapshot.Bytes(), 1471 } 1472 return err 1473 } 1474 1475 errorBody.Seek(0, io.SeekStart) 1476 if len(code) != 0 { 1477 errorCode = restjson.SanitizeErrorCode(code) 1478 } 1479 if len(message) != 0 { 1480 errorMessage = message 1481 } 1482 1483 switch { 1484 case strings.EqualFold("AssociatedEndpointGroupFoundException", errorCode): 1485 return awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response, errorBody) 1486 1487 case strings.EqualFold("InternalServiceErrorException", errorCode): 1488 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1489 1490 case strings.EqualFold("InvalidArgumentException", errorCode): 1491 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1492 1493 case strings.EqualFold("ListenerNotFoundException", errorCode): 1494 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 1495 1496 default: 1497 genericError := &smithy.GenericAPIError{ 1498 Code: errorCode, 1499 Message: errorMessage, 1500 } 1501 return genericError 1502 1503 } 1504} 1505 1506type awsAwsjson11_deserializeOpDeleteEndpointGroup struct { 1507} 1508 1509func (*awsAwsjson11_deserializeOpDeleteEndpointGroup) ID() string { 1510 return "OperationDeserializer" 1511} 1512 1513func (m *awsAwsjson11_deserializeOpDeleteEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1514 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1515) { 1516 out, metadata, err = next.HandleDeserialize(ctx, in) 1517 if err != nil { 1518 return out, metadata, err 1519 } 1520 1521 response, ok := out.RawResponse.(*smithyhttp.Response) 1522 if !ok { 1523 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1524 } 1525 1526 if response.StatusCode < 200 || response.StatusCode >= 300 { 1527 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteEndpointGroup(response, &metadata) 1528 } 1529 output := &DeleteEndpointGroupOutput{} 1530 out.Result = output 1531 1532 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1533 return out, metadata, &smithy.DeserializationError{ 1534 Err: fmt.Errorf("failed to discard response body, %w", err), 1535 } 1536 } 1537 1538 return out, metadata, err 1539} 1540 1541func awsAwsjson11_deserializeOpErrorDeleteEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1542 var errorBuffer bytes.Buffer 1543 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1544 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1545 } 1546 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1547 1548 errorCode := "UnknownError" 1549 errorMessage := errorCode 1550 1551 code := response.Header.Get("X-Amzn-ErrorType") 1552 if len(code) != 0 { 1553 errorCode = restjson.SanitizeErrorCode(code) 1554 } 1555 1556 var buff [1024]byte 1557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1558 1559 body := io.TeeReader(errorBody, ringBuffer) 1560 decoder := json.NewDecoder(body) 1561 decoder.UseNumber() 1562 code, message, err := restjson.GetErrorInfo(decoder) 1563 if err != nil { 1564 var snapshot bytes.Buffer 1565 io.Copy(&snapshot, ringBuffer) 1566 err = &smithy.DeserializationError{ 1567 Err: fmt.Errorf("failed to decode response body, %w", err), 1568 Snapshot: snapshot.Bytes(), 1569 } 1570 return err 1571 } 1572 1573 errorBody.Seek(0, io.SeekStart) 1574 if len(code) != 0 { 1575 errorCode = restjson.SanitizeErrorCode(code) 1576 } 1577 if len(message) != 0 { 1578 errorMessage = message 1579 } 1580 1581 switch { 1582 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 1583 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 1584 1585 case strings.EqualFold("InternalServiceErrorException", errorCode): 1586 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1587 1588 case strings.EqualFold("InvalidArgumentException", errorCode): 1589 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1590 1591 default: 1592 genericError := &smithy.GenericAPIError{ 1593 Code: errorCode, 1594 Message: errorMessage, 1595 } 1596 return genericError 1597 1598 } 1599} 1600 1601type awsAwsjson11_deserializeOpDeleteListener struct { 1602} 1603 1604func (*awsAwsjson11_deserializeOpDeleteListener) ID() string { 1605 return "OperationDeserializer" 1606} 1607 1608func (m *awsAwsjson11_deserializeOpDeleteListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1609 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1610) { 1611 out, metadata, err = next.HandleDeserialize(ctx, in) 1612 if err != nil { 1613 return out, metadata, err 1614 } 1615 1616 response, ok := out.RawResponse.(*smithyhttp.Response) 1617 if !ok { 1618 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1619 } 1620 1621 if response.StatusCode < 200 || response.StatusCode >= 300 { 1622 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteListener(response, &metadata) 1623 } 1624 output := &DeleteListenerOutput{} 1625 out.Result = output 1626 1627 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1628 return out, metadata, &smithy.DeserializationError{ 1629 Err: fmt.Errorf("failed to discard response body, %w", err), 1630 } 1631 } 1632 1633 return out, metadata, err 1634} 1635 1636func awsAwsjson11_deserializeOpErrorDeleteListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1637 var errorBuffer bytes.Buffer 1638 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1639 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1640 } 1641 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1642 1643 errorCode := "UnknownError" 1644 errorMessage := errorCode 1645 1646 code := response.Header.Get("X-Amzn-ErrorType") 1647 if len(code) != 0 { 1648 errorCode = restjson.SanitizeErrorCode(code) 1649 } 1650 1651 var buff [1024]byte 1652 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1653 1654 body := io.TeeReader(errorBody, ringBuffer) 1655 decoder := json.NewDecoder(body) 1656 decoder.UseNumber() 1657 code, message, err := restjson.GetErrorInfo(decoder) 1658 if err != nil { 1659 var snapshot bytes.Buffer 1660 io.Copy(&snapshot, ringBuffer) 1661 err = &smithy.DeserializationError{ 1662 Err: fmt.Errorf("failed to decode response body, %w", err), 1663 Snapshot: snapshot.Bytes(), 1664 } 1665 return err 1666 } 1667 1668 errorBody.Seek(0, io.SeekStart) 1669 if len(code) != 0 { 1670 errorCode = restjson.SanitizeErrorCode(code) 1671 } 1672 if len(message) != 0 { 1673 errorMessage = message 1674 } 1675 1676 switch { 1677 case strings.EqualFold("AssociatedEndpointGroupFoundException", errorCode): 1678 return awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response, errorBody) 1679 1680 case strings.EqualFold("InternalServiceErrorException", errorCode): 1681 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1682 1683 case strings.EqualFold("InvalidArgumentException", errorCode): 1684 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1685 1686 case strings.EqualFold("ListenerNotFoundException", errorCode): 1687 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 1688 1689 default: 1690 genericError := &smithy.GenericAPIError{ 1691 Code: errorCode, 1692 Message: errorMessage, 1693 } 1694 return genericError 1695 1696 } 1697} 1698 1699type awsAwsjson11_deserializeOpDenyCustomRoutingTraffic struct { 1700} 1701 1702func (*awsAwsjson11_deserializeOpDenyCustomRoutingTraffic) ID() string { 1703 return "OperationDeserializer" 1704} 1705 1706func (m *awsAwsjson11_deserializeOpDenyCustomRoutingTraffic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1707 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1708) { 1709 out, metadata, err = next.HandleDeserialize(ctx, in) 1710 if err != nil { 1711 return out, metadata, err 1712 } 1713 1714 response, ok := out.RawResponse.(*smithyhttp.Response) 1715 if !ok { 1716 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1717 } 1718 1719 if response.StatusCode < 200 || response.StatusCode >= 300 { 1720 return out, metadata, awsAwsjson11_deserializeOpErrorDenyCustomRoutingTraffic(response, &metadata) 1721 } 1722 output := &DenyCustomRoutingTrafficOutput{} 1723 out.Result = output 1724 1725 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1726 return out, metadata, &smithy.DeserializationError{ 1727 Err: fmt.Errorf("failed to discard response body, %w", err), 1728 } 1729 } 1730 1731 return out, metadata, err 1732} 1733 1734func awsAwsjson11_deserializeOpErrorDenyCustomRoutingTraffic(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1735 var errorBuffer bytes.Buffer 1736 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1737 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1738 } 1739 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1740 1741 errorCode := "UnknownError" 1742 errorMessage := errorCode 1743 1744 code := response.Header.Get("X-Amzn-ErrorType") 1745 if len(code) != 0 { 1746 errorCode = restjson.SanitizeErrorCode(code) 1747 } 1748 1749 var buff [1024]byte 1750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1751 1752 body := io.TeeReader(errorBody, ringBuffer) 1753 decoder := json.NewDecoder(body) 1754 decoder.UseNumber() 1755 code, message, err := restjson.GetErrorInfo(decoder) 1756 if err != nil { 1757 var snapshot bytes.Buffer 1758 io.Copy(&snapshot, ringBuffer) 1759 err = &smithy.DeserializationError{ 1760 Err: fmt.Errorf("failed to decode response body, %w", err), 1761 Snapshot: snapshot.Bytes(), 1762 } 1763 return err 1764 } 1765 1766 errorBody.Seek(0, io.SeekStart) 1767 if len(code) != 0 { 1768 errorCode = restjson.SanitizeErrorCode(code) 1769 } 1770 if len(message) != 0 { 1771 errorMessage = message 1772 } 1773 1774 switch { 1775 case strings.EqualFold("InternalServiceErrorException", errorCode): 1776 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1777 1778 case strings.EqualFold("InvalidArgumentException", errorCode): 1779 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1780 1781 default: 1782 genericError := &smithy.GenericAPIError{ 1783 Code: errorCode, 1784 Message: errorMessage, 1785 } 1786 return genericError 1787 1788 } 1789} 1790 1791type awsAwsjson11_deserializeOpDeprovisionByoipCidr struct { 1792} 1793 1794func (*awsAwsjson11_deserializeOpDeprovisionByoipCidr) ID() string { 1795 return "OperationDeserializer" 1796} 1797 1798func (m *awsAwsjson11_deserializeOpDeprovisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1799 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1800) { 1801 out, metadata, err = next.HandleDeserialize(ctx, in) 1802 if err != nil { 1803 return out, metadata, err 1804 } 1805 1806 response, ok := out.RawResponse.(*smithyhttp.Response) 1807 if !ok { 1808 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1809 } 1810 1811 if response.StatusCode < 200 || response.StatusCode >= 300 { 1812 return out, metadata, awsAwsjson11_deserializeOpErrorDeprovisionByoipCidr(response, &metadata) 1813 } 1814 output := &DeprovisionByoipCidrOutput{} 1815 out.Result = output 1816 1817 var buff [1024]byte 1818 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1819 1820 body := io.TeeReader(response.Body, ringBuffer) 1821 decoder := json.NewDecoder(body) 1822 decoder.UseNumber() 1823 var shape interface{} 1824 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1825 var snapshot bytes.Buffer 1826 io.Copy(&snapshot, ringBuffer) 1827 err = &smithy.DeserializationError{ 1828 Err: fmt.Errorf("failed to decode response body, %w", err), 1829 Snapshot: snapshot.Bytes(), 1830 } 1831 return out, metadata, err 1832 } 1833 1834 err = awsAwsjson11_deserializeOpDocumentDeprovisionByoipCidrOutput(&output, shape) 1835 if err != nil { 1836 var snapshot bytes.Buffer 1837 io.Copy(&snapshot, ringBuffer) 1838 err = &smithy.DeserializationError{ 1839 Err: fmt.Errorf("failed to decode response body, %w", err), 1840 Snapshot: snapshot.Bytes(), 1841 } 1842 return out, metadata, err 1843 } 1844 1845 return out, metadata, err 1846} 1847 1848func awsAwsjson11_deserializeOpErrorDeprovisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1849 var errorBuffer bytes.Buffer 1850 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1851 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1852 } 1853 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1854 1855 errorCode := "UnknownError" 1856 errorMessage := errorCode 1857 1858 code := response.Header.Get("X-Amzn-ErrorType") 1859 if len(code) != 0 { 1860 errorCode = restjson.SanitizeErrorCode(code) 1861 } 1862 1863 var buff [1024]byte 1864 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1865 1866 body := io.TeeReader(errorBody, ringBuffer) 1867 decoder := json.NewDecoder(body) 1868 decoder.UseNumber() 1869 code, message, err := restjson.GetErrorInfo(decoder) 1870 if err != nil { 1871 var snapshot bytes.Buffer 1872 io.Copy(&snapshot, ringBuffer) 1873 err = &smithy.DeserializationError{ 1874 Err: fmt.Errorf("failed to decode response body, %w", err), 1875 Snapshot: snapshot.Bytes(), 1876 } 1877 return err 1878 } 1879 1880 errorBody.Seek(0, io.SeekStart) 1881 if len(code) != 0 { 1882 errorCode = restjson.SanitizeErrorCode(code) 1883 } 1884 if len(message) != 0 { 1885 errorMessage = message 1886 } 1887 1888 switch { 1889 case strings.EqualFold("AccessDeniedException", errorCode): 1890 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1891 1892 case strings.EqualFold("ByoipCidrNotFoundException", errorCode): 1893 return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody) 1894 1895 case strings.EqualFold("IncorrectCidrStateException", errorCode): 1896 return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody) 1897 1898 case strings.EqualFold("InternalServiceErrorException", errorCode): 1899 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 1900 1901 case strings.EqualFold("InvalidArgumentException", errorCode): 1902 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 1903 1904 default: 1905 genericError := &smithy.GenericAPIError{ 1906 Code: errorCode, 1907 Message: errorMessage, 1908 } 1909 return genericError 1910 1911 } 1912} 1913 1914type awsAwsjson11_deserializeOpDescribeAccelerator struct { 1915} 1916 1917func (*awsAwsjson11_deserializeOpDescribeAccelerator) ID() string { 1918 return "OperationDeserializer" 1919} 1920 1921func (m *awsAwsjson11_deserializeOpDescribeAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1922 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1923) { 1924 out, metadata, err = next.HandleDeserialize(ctx, in) 1925 if err != nil { 1926 return out, metadata, err 1927 } 1928 1929 response, ok := out.RawResponse.(*smithyhttp.Response) 1930 if !ok { 1931 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1932 } 1933 1934 if response.StatusCode < 200 || response.StatusCode >= 300 { 1935 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccelerator(response, &metadata) 1936 } 1937 output := &DescribeAcceleratorOutput{} 1938 out.Result = output 1939 1940 var buff [1024]byte 1941 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1942 1943 body := io.TeeReader(response.Body, ringBuffer) 1944 decoder := json.NewDecoder(body) 1945 decoder.UseNumber() 1946 var shape interface{} 1947 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1948 var snapshot bytes.Buffer 1949 io.Copy(&snapshot, ringBuffer) 1950 err = &smithy.DeserializationError{ 1951 Err: fmt.Errorf("failed to decode response body, %w", err), 1952 Snapshot: snapshot.Bytes(), 1953 } 1954 return out, metadata, err 1955 } 1956 1957 err = awsAwsjson11_deserializeOpDocumentDescribeAcceleratorOutput(&output, shape) 1958 if err != nil { 1959 var snapshot bytes.Buffer 1960 io.Copy(&snapshot, ringBuffer) 1961 err = &smithy.DeserializationError{ 1962 Err: fmt.Errorf("failed to decode response body, %w", err), 1963 Snapshot: snapshot.Bytes(), 1964 } 1965 return out, metadata, err 1966 } 1967 1968 return out, metadata, err 1969} 1970 1971func awsAwsjson11_deserializeOpErrorDescribeAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1972 var errorBuffer bytes.Buffer 1973 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1974 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1975 } 1976 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1977 1978 errorCode := "UnknownError" 1979 errorMessage := errorCode 1980 1981 code := response.Header.Get("X-Amzn-ErrorType") 1982 if len(code) != 0 { 1983 errorCode = restjson.SanitizeErrorCode(code) 1984 } 1985 1986 var buff [1024]byte 1987 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1988 1989 body := io.TeeReader(errorBody, ringBuffer) 1990 decoder := json.NewDecoder(body) 1991 decoder.UseNumber() 1992 code, message, err := restjson.GetErrorInfo(decoder) 1993 if err != nil { 1994 var snapshot bytes.Buffer 1995 io.Copy(&snapshot, ringBuffer) 1996 err = &smithy.DeserializationError{ 1997 Err: fmt.Errorf("failed to decode response body, %w", err), 1998 Snapshot: snapshot.Bytes(), 1999 } 2000 return err 2001 } 2002 2003 errorBody.Seek(0, io.SeekStart) 2004 if len(code) != 0 { 2005 errorCode = restjson.SanitizeErrorCode(code) 2006 } 2007 if len(message) != 0 { 2008 errorMessage = message 2009 } 2010 2011 switch { 2012 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 2013 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 2014 2015 case strings.EqualFold("InternalServiceErrorException", errorCode): 2016 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2017 2018 case strings.EqualFold("InvalidArgumentException", errorCode): 2019 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2020 2021 default: 2022 genericError := &smithy.GenericAPIError{ 2023 Code: errorCode, 2024 Message: errorMessage, 2025 } 2026 return genericError 2027 2028 } 2029} 2030 2031type awsAwsjson11_deserializeOpDescribeAcceleratorAttributes struct { 2032} 2033 2034func (*awsAwsjson11_deserializeOpDescribeAcceleratorAttributes) ID() string { 2035 return "OperationDeserializer" 2036} 2037 2038func (m *awsAwsjson11_deserializeOpDescribeAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2039 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2040) { 2041 out, metadata, err = next.HandleDeserialize(ctx, in) 2042 if err != nil { 2043 return out, metadata, err 2044 } 2045 2046 response, ok := out.RawResponse.(*smithyhttp.Response) 2047 if !ok { 2048 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2049 } 2050 2051 if response.StatusCode < 200 || response.StatusCode >= 300 { 2052 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAcceleratorAttributes(response, &metadata) 2053 } 2054 output := &DescribeAcceleratorAttributesOutput{} 2055 out.Result = output 2056 2057 var buff [1024]byte 2058 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2059 2060 body := io.TeeReader(response.Body, ringBuffer) 2061 decoder := json.NewDecoder(body) 2062 decoder.UseNumber() 2063 var shape interface{} 2064 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2065 var snapshot bytes.Buffer 2066 io.Copy(&snapshot, ringBuffer) 2067 err = &smithy.DeserializationError{ 2068 Err: fmt.Errorf("failed to decode response body, %w", err), 2069 Snapshot: snapshot.Bytes(), 2070 } 2071 return out, metadata, err 2072 } 2073 2074 err = awsAwsjson11_deserializeOpDocumentDescribeAcceleratorAttributesOutput(&output, shape) 2075 if err != nil { 2076 var snapshot bytes.Buffer 2077 io.Copy(&snapshot, ringBuffer) 2078 err = &smithy.DeserializationError{ 2079 Err: fmt.Errorf("failed to decode response body, %w", err), 2080 Snapshot: snapshot.Bytes(), 2081 } 2082 return out, metadata, err 2083 } 2084 2085 return out, metadata, err 2086} 2087 2088func awsAwsjson11_deserializeOpErrorDescribeAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2089 var errorBuffer bytes.Buffer 2090 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2091 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2092 } 2093 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2094 2095 errorCode := "UnknownError" 2096 errorMessage := errorCode 2097 2098 code := response.Header.Get("X-Amzn-ErrorType") 2099 if len(code) != 0 { 2100 errorCode = restjson.SanitizeErrorCode(code) 2101 } 2102 2103 var buff [1024]byte 2104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2105 2106 body := io.TeeReader(errorBody, ringBuffer) 2107 decoder := json.NewDecoder(body) 2108 decoder.UseNumber() 2109 code, message, err := restjson.GetErrorInfo(decoder) 2110 if err != nil { 2111 var snapshot bytes.Buffer 2112 io.Copy(&snapshot, ringBuffer) 2113 err = &smithy.DeserializationError{ 2114 Err: fmt.Errorf("failed to decode response body, %w", err), 2115 Snapshot: snapshot.Bytes(), 2116 } 2117 return err 2118 } 2119 2120 errorBody.Seek(0, io.SeekStart) 2121 if len(code) != 0 { 2122 errorCode = restjson.SanitizeErrorCode(code) 2123 } 2124 if len(message) != 0 { 2125 errorMessage = message 2126 } 2127 2128 switch { 2129 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 2130 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 2131 2132 case strings.EqualFold("InternalServiceErrorException", errorCode): 2133 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2134 2135 case strings.EqualFold("InvalidArgumentException", errorCode): 2136 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2137 2138 default: 2139 genericError := &smithy.GenericAPIError{ 2140 Code: errorCode, 2141 Message: errorMessage, 2142 } 2143 return genericError 2144 2145 } 2146} 2147 2148type awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator struct { 2149} 2150 2151func (*awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator) ID() string { 2152 return "OperationDeserializer" 2153} 2154 2155func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2156 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2157) { 2158 out, metadata, err = next.HandleDeserialize(ctx, in) 2159 if err != nil { 2160 return out, metadata, err 2161 } 2162 2163 response, ok := out.RawResponse.(*smithyhttp.Response) 2164 if !ok { 2165 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2166 } 2167 2168 if response.StatusCode < 200 || response.StatusCode >= 300 { 2169 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAccelerator(response, &metadata) 2170 } 2171 output := &DescribeCustomRoutingAcceleratorOutput{} 2172 out.Result = output 2173 2174 var buff [1024]byte 2175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2176 2177 body := io.TeeReader(response.Body, ringBuffer) 2178 decoder := json.NewDecoder(body) 2179 decoder.UseNumber() 2180 var shape interface{} 2181 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2182 var snapshot bytes.Buffer 2183 io.Copy(&snapshot, ringBuffer) 2184 err = &smithy.DeserializationError{ 2185 Err: fmt.Errorf("failed to decode response body, %w", err), 2186 Snapshot: snapshot.Bytes(), 2187 } 2188 return out, metadata, err 2189 } 2190 2191 err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorOutput(&output, shape) 2192 if err != nil { 2193 var snapshot bytes.Buffer 2194 io.Copy(&snapshot, ringBuffer) 2195 err = &smithy.DeserializationError{ 2196 Err: fmt.Errorf("failed to decode response body, %w", err), 2197 Snapshot: snapshot.Bytes(), 2198 } 2199 return out, metadata, err 2200 } 2201 2202 return out, metadata, err 2203} 2204 2205func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2206 var errorBuffer bytes.Buffer 2207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2209 } 2210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2211 2212 errorCode := "UnknownError" 2213 errorMessage := errorCode 2214 2215 code := response.Header.Get("X-Amzn-ErrorType") 2216 if len(code) != 0 { 2217 errorCode = restjson.SanitizeErrorCode(code) 2218 } 2219 2220 var buff [1024]byte 2221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2222 2223 body := io.TeeReader(errorBody, ringBuffer) 2224 decoder := json.NewDecoder(body) 2225 decoder.UseNumber() 2226 code, message, err := restjson.GetErrorInfo(decoder) 2227 if err != nil { 2228 var snapshot bytes.Buffer 2229 io.Copy(&snapshot, ringBuffer) 2230 err = &smithy.DeserializationError{ 2231 Err: fmt.Errorf("failed to decode response body, %w", err), 2232 Snapshot: snapshot.Bytes(), 2233 } 2234 return err 2235 } 2236 2237 errorBody.Seek(0, io.SeekStart) 2238 if len(code) != 0 { 2239 errorCode = restjson.SanitizeErrorCode(code) 2240 } 2241 if len(message) != 0 { 2242 errorMessage = message 2243 } 2244 2245 switch { 2246 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 2247 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 2248 2249 case strings.EqualFold("InternalServiceErrorException", errorCode): 2250 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2251 2252 case strings.EqualFold("InvalidArgumentException", errorCode): 2253 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2254 2255 default: 2256 genericError := &smithy.GenericAPIError{ 2257 Code: errorCode, 2258 Message: errorMessage, 2259 } 2260 return genericError 2261 2262 } 2263} 2264 2265type awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes struct { 2266} 2267 2268func (*awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes) ID() string { 2269 return "OperationDeserializer" 2270} 2271 2272func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2273 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2274) { 2275 out, metadata, err = next.HandleDeserialize(ctx, in) 2276 if err != nil { 2277 return out, metadata, err 2278 } 2279 2280 response, ok := out.RawResponse.(*smithyhttp.Response) 2281 if !ok { 2282 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2283 } 2284 2285 if response.StatusCode < 200 || response.StatusCode >= 300 { 2286 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAcceleratorAttributes(response, &metadata) 2287 } 2288 output := &DescribeCustomRoutingAcceleratorAttributesOutput{} 2289 out.Result = output 2290 2291 var buff [1024]byte 2292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2293 2294 body := io.TeeReader(response.Body, ringBuffer) 2295 decoder := json.NewDecoder(body) 2296 decoder.UseNumber() 2297 var shape interface{} 2298 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2299 var snapshot bytes.Buffer 2300 io.Copy(&snapshot, ringBuffer) 2301 err = &smithy.DeserializationError{ 2302 Err: fmt.Errorf("failed to decode response body, %w", err), 2303 Snapshot: snapshot.Bytes(), 2304 } 2305 return out, metadata, err 2306 } 2307 2308 err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorAttributesOutput(&output, shape) 2309 if err != nil { 2310 var snapshot bytes.Buffer 2311 io.Copy(&snapshot, ringBuffer) 2312 err = &smithy.DeserializationError{ 2313 Err: fmt.Errorf("failed to decode response body, %w", err), 2314 Snapshot: snapshot.Bytes(), 2315 } 2316 return out, metadata, err 2317 } 2318 2319 return out, metadata, err 2320} 2321 2322func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2323 var errorBuffer bytes.Buffer 2324 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2325 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2326 } 2327 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2328 2329 errorCode := "UnknownError" 2330 errorMessage := errorCode 2331 2332 code := response.Header.Get("X-Amzn-ErrorType") 2333 if len(code) != 0 { 2334 errorCode = restjson.SanitizeErrorCode(code) 2335 } 2336 2337 var buff [1024]byte 2338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2339 2340 body := io.TeeReader(errorBody, ringBuffer) 2341 decoder := json.NewDecoder(body) 2342 decoder.UseNumber() 2343 code, message, err := restjson.GetErrorInfo(decoder) 2344 if err != nil { 2345 var snapshot bytes.Buffer 2346 io.Copy(&snapshot, ringBuffer) 2347 err = &smithy.DeserializationError{ 2348 Err: fmt.Errorf("failed to decode response body, %w", err), 2349 Snapshot: snapshot.Bytes(), 2350 } 2351 return err 2352 } 2353 2354 errorBody.Seek(0, io.SeekStart) 2355 if len(code) != 0 { 2356 errorCode = restjson.SanitizeErrorCode(code) 2357 } 2358 if len(message) != 0 { 2359 errorMessage = message 2360 } 2361 2362 switch { 2363 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 2364 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 2365 2366 case strings.EqualFold("InternalServiceErrorException", errorCode): 2367 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2368 2369 case strings.EqualFold("InvalidArgumentException", errorCode): 2370 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2371 2372 default: 2373 genericError := &smithy.GenericAPIError{ 2374 Code: errorCode, 2375 Message: errorMessage, 2376 } 2377 return genericError 2378 2379 } 2380} 2381 2382type awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup struct { 2383} 2384 2385func (*awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup) ID() string { 2386 return "OperationDeserializer" 2387} 2388 2389func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2390 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2391) { 2392 out, metadata, err = next.HandleDeserialize(ctx, in) 2393 if err != nil { 2394 return out, metadata, err 2395 } 2396 2397 response, ok := out.RawResponse.(*smithyhttp.Response) 2398 if !ok { 2399 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2400 } 2401 2402 if response.StatusCode < 200 || response.StatusCode >= 300 { 2403 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingEndpointGroup(response, &metadata) 2404 } 2405 output := &DescribeCustomRoutingEndpointGroupOutput{} 2406 out.Result = output 2407 2408 var buff [1024]byte 2409 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2410 2411 body := io.TeeReader(response.Body, ringBuffer) 2412 decoder := json.NewDecoder(body) 2413 decoder.UseNumber() 2414 var shape interface{} 2415 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2416 var snapshot bytes.Buffer 2417 io.Copy(&snapshot, ringBuffer) 2418 err = &smithy.DeserializationError{ 2419 Err: fmt.Errorf("failed to decode response body, %w", err), 2420 Snapshot: snapshot.Bytes(), 2421 } 2422 return out, metadata, err 2423 } 2424 2425 err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingEndpointGroupOutput(&output, shape) 2426 if err != nil { 2427 var snapshot bytes.Buffer 2428 io.Copy(&snapshot, ringBuffer) 2429 err = &smithy.DeserializationError{ 2430 Err: fmt.Errorf("failed to decode response body, %w", err), 2431 Snapshot: snapshot.Bytes(), 2432 } 2433 return out, metadata, err 2434 } 2435 2436 return out, metadata, err 2437} 2438 2439func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2440 var errorBuffer bytes.Buffer 2441 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2442 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2443 } 2444 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2445 2446 errorCode := "UnknownError" 2447 errorMessage := errorCode 2448 2449 code := response.Header.Get("X-Amzn-ErrorType") 2450 if len(code) != 0 { 2451 errorCode = restjson.SanitizeErrorCode(code) 2452 } 2453 2454 var buff [1024]byte 2455 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2456 2457 body := io.TeeReader(errorBody, ringBuffer) 2458 decoder := json.NewDecoder(body) 2459 decoder.UseNumber() 2460 code, message, err := restjson.GetErrorInfo(decoder) 2461 if err != nil { 2462 var snapshot bytes.Buffer 2463 io.Copy(&snapshot, ringBuffer) 2464 err = &smithy.DeserializationError{ 2465 Err: fmt.Errorf("failed to decode response body, %w", err), 2466 Snapshot: snapshot.Bytes(), 2467 } 2468 return err 2469 } 2470 2471 errorBody.Seek(0, io.SeekStart) 2472 if len(code) != 0 { 2473 errorCode = restjson.SanitizeErrorCode(code) 2474 } 2475 if len(message) != 0 { 2476 errorMessage = message 2477 } 2478 2479 switch { 2480 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 2481 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 2482 2483 case strings.EqualFold("InternalServiceErrorException", errorCode): 2484 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2485 2486 case strings.EqualFold("InvalidArgumentException", errorCode): 2487 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2488 2489 default: 2490 genericError := &smithy.GenericAPIError{ 2491 Code: errorCode, 2492 Message: errorMessage, 2493 } 2494 return genericError 2495 2496 } 2497} 2498 2499type awsAwsjson11_deserializeOpDescribeCustomRoutingListener struct { 2500} 2501 2502func (*awsAwsjson11_deserializeOpDescribeCustomRoutingListener) ID() string { 2503 return "OperationDeserializer" 2504} 2505 2506func (m *awsAwsjson11_deserializeOpDescribeCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2507 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2508) { 2509 out, metadata, err = next.HandleDeserialize(ctx, in) 2510 if err != nil { 2511 return out, metadata, err 2512 } 2513 2514 response, ok := out.RawResponse.(*smithyhttp.Response) 2515 if !ok { 2516 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2517 } 2518 2519 if response.StatusCode < 200 || response.StatusCode >= 300 { 2520 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCustomRoutingListener(response, &metadata) 2521 } 2522 output := &DescribeCustomRoutingListenerOutput{} 2523 out.Result = output 2524 2525 var buff [1024]byte 2526 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2527 2528 body := io.TeeReader(response.Body, ringBuffer) 2529 decoder := json.NewDecoder(body) 2530 decoder.UseNumber() 2531 var shape interface{} 2532 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2533 var snapshot bytes.Buffer 2534 io.Copy(&snapshot, ringBuffer) 2535 err = &smithy.DeserializationError{ 2536 Err: fmt.Errorf("failed to decode response body, %w", err), 2537 Snapshot: snapshot.Bytes(), 2538 } 2539 return out, metadata, err 2540 } 2541 2542 err = awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingListenerOutput(&output, shape) 2543 if err != nil { 2544 var snapshot bytes.Buffer 2545 io.Copy(&snapshot, ringBuffer) 2546 err = &smithy.DeserializationError{ 2547 Err: fmt.Errorf("failed to decode response body, %w", err), 2548 Snapshot: snapshot.Bytes(), 2549 } 2550 return out, metadata, err 2551 } 2552 2553 return out, metadata, err 2554} 2555 2556func awsAwsjson11_deserializeOpErrorDescribeCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2557 var errorBuffer bytes.Buffer 2558 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2559 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2560 } 2561 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2562 2563 errorCode := "UnknownError" 2564 errorMessage := errorCode 2565 2566 code := response.Header.Get("X-Amzn-ErrorType") 2567 if len(code) != 0 { 2568 errorCode = restjson.SanitizeErrorCode(code) 2569 } 2570 2571 var buff [1024]byte 2572 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2573 2574 body := io.TeeReader(errorBody, ringBuffer) 2575 decoder := json.NewDecoder(body) 2576 decoder.UseNumber() 2577 code, message, err := restjson.GetErrorInfo(decoder) 2578 if err != nil { 2579 var snapshot bytes.Buffer 2580 io.Copy(&snapshot, ringBuffer) 2581 err = &smithy.DeserializationError{ 2582 Err: fmt.Errorf("failed to decode response body, %w", err), 2583 Snapshot: snapshot.Bytes(), 2584 } 2585 return err 2586 } 2587 2588 errorBody.Seek(0, io.SeekStart) 2589 if len(code) != 0 { 2590 errorCode = restjson.SanitizeErrorCode(code) 2591 } 2592 if len(message) != 0 { 2593 errorMessage = message 2594 } 2595 2596 switch { 2597 case strings.EqualFold("InternalServiceErrorException", errorCode): 2598 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2599 2600 case strings.EqualFold("InvalidArgumentException", errorCode): 2601 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2602 2603 case strings.EqualFold("ListenerNotFoundException", errorCode): 2604 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 2605 2606 default: 2607 genericError := &smithy.GenericAPIError{ 2608 Code: errorCode, 2609 Message: errorMessage, 2610 } 2611 return genericError 2612 2613 } 2614} 2615 2616type awsAwsjson11_deserializeOpDescribeEndpointGroup struct { 2617} 2618 2619func (*awsAwsjson11_deserializeOpDescribeEndpointGroup) ID() string { 2620 return "OperationDeserializer" 2621} 2622 2623func (m *awsAwsjson11_deserializeOpDescribeEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2624 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2625) { 2626 out, metadata, err = next.HandleDeserialize(ctx, in) 2627 if err != nil { 2628 return out, metadata, err 2629 } 2630 2631 response, ok := out.RawResponse.(*smithyhttp.Response) 2632 if !ok { 2633 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2634 } 2635 2636 if response.StatusCode < 200 || response.StatusCode >= 300 { 2637 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEndpointGroup(response, &metadata) 2638 } 2639 output := &DescribeEndpointGroupOutput{} 2640 out.Result = output 2641 2642 var buff [1024]byte 2643 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2644 2645 body := io.TeeReader(response.Body, ringBuffer) 2646 decoder := json.NewDecoder(body) 2647 decoder.UseNumber() 2648 var shape interface{} 2649 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2650 var snapshot bytes.Buffer 2651 io.Copy(&snapshot, ringBuffer) 2652 err = &smithy.DeserializationError{ 2653 Err: fmt.Errorf("failed to decode response body, %w", err), 2654 Snapshot: snapshot.Bytes(), 2655 } 2656 return out, metadata, err 2657 } 2658 2659 err = awsAwsjson11_deserializeOpDocumentDescribeEndpointGroupOutput(&output, shape) 2660 if err != nil { 2661 var snapshot bytes.Buffer 2662 io.Copy(&snapshot, ringBuffer) 2663 err = &smithy.DeserializationError{ 2664 Err: fmt.Errorf("failed to decode response body, %w", err), 2665 Snapshot: snapshot.Bytes(), 2666 } 2667 return out, metadata, err 2668 } 2669 2670 return out, metadata, err 2671} 2672 2673func awsAwsjson11_deserializeOpErrorDescribeEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2674 var errorBuffer bytes.Buffer 2675 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2676 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2677 } 2678 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2679 2680 errorCode := "UnknownError" 2681 errorMessage := errorCode 2682 2683 code := response.Header.Get("X-Amzn-ErrorType") 2684 if len(code) != 0 { 2685 errorCode = restjson.SanitizeErrorCode(code) 2686 } 2687 2688 var buff [1024]byte 2689 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2690 2691 body := io.TeeReader(errorBody, ringBuffer) 2692 decoder := json.NewDecoder(body) 2693 decoder.UseNumber() 2694 code, message, err := restjson.GetErrorInfo(decoder) 2695 if err != nil { 2696 var snapshot bytes.Buffer 2697 io.Copy(&snapshot, ringBuffer) 2698 err = &smithy.DeserializationError{ 2699 Err: fmt.Errorf("failed to decode response body, %w", err), 2700 Snapshot: snapshot.Bytes(), 2701 } 2702 return err 2703 } 2704 2705 errorBody.Seek(0, io.SeekStart) 2706 if len(code) != 0 { 2707 errorCode = restjson.SanitizeErrorCode(code) 2708 } 2709 if len(message) != 0 { 2710 errorMessage = message 2711 } 2712 2713 switch { 2714 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 2715 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 2716 2717 case strings.EqualFold("InternalServiceErrorException", errorCode): 2718 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2719 2720 case strings.EqualFold("InvalidArgumentException", errorCode): 2721 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2722 2723 default: 2724 genericError := &smithy.GenericAPIError{ 2725 Code: errorCode, 2726 Message: errorMessage, 2727 } 2728 return genericError 2729 2730 } 2731} 2732 2733type awsAwsjson11_deserializeOpDescribeListener struct { 2734} 2735 2736func (*awsAwsjson11_deserializeOpDescribeListener) ID() string { 2737 return "OperationDeserializer" 2738} 2739 2740func (m *awsAwsjson11_deserializeOpDescribeListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2741 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2742) { 2743 out, metadata, err = next.HandleDeserialize(ctx, in) 2744 if err != nil { 2745 return out, metadata, err 2746 } 2747 2748 response, ok := out.RawResponse.(*smithyhttp.Response) 2749 if !ok { 2750 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2751 } 2752 2753 if response.StatusCode < 200 || response.StatusCode >= 300 { 2754 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeListener(response, &metadata) 2755 } 2756 output := &DescribeListenerOutput{} 2757 out.Result = output 2758 2759 var buff [1024]byte 2760 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2761 2762 body := io.TeeReader(response.Body, ringBuffer) 2763 decoder := json.NewDecoder(body) 2764 decoder.UseNumber() 2765 var shape interface{} 2766 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2767 var snapshot bytes.Buffer 2768 io.Copy(&snapshot, ringBuffer) 2769 err = &smithy.DeserializationError{ 2770 Err: fmt.Errorf("failed to decode response body, %w", err), 2771 Snapshot: snapshot.Bytes(), 2772 } 2773 return out, metadata, err 2774 } 2775 2776 err = awsAwsjson11_deserializeOpDocumentDescribeListenerOutput(&output, shape) 2777 if err != nil { 2778 var snapshot bytes.Buffer 2779 io.Copy(&snapshot, ringBuffer) 2780 err = &smithy.DeserializationError{ 2781 Err: fmt.Errorf("failed to decode response body, %w", err), 2782 Snapshot: snapshot.Bytes(), 2783 } 2784 return out, metadata, err 2785 } 2786 2787 return out, metadata, err 2788} 2789 2790func awsAwsjson11_deserializeOpErrorDescribeListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2791 var errorBuffer bytes.Buffer 2792 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2793 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2794 } 2795 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2796 2797 errorCode := "UnknownError" 2798 errorMessage := errorCode 2799 2800 code := response.Header.Get("X-Amzn-ErrorType") 2801 if len(code) != 0 { 2802 errorCode = restjson.SanitizeErrorCode(code) 2803 } 2804 2805 var buff [1024]byte 2806 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2807 2808 body := io.TeeReader(errorBody, ringBuffer) 2809 decoder := json.NewDecoder(body) 2810 decoder.UseNumber() 2811 code, message, err := restjson.GetErrorInfo(decoder) 2812 if err != nil { 2813 var snapshot bytes.Buffer 2814 io.Copy(&snapshot, ringBuffer) 2815 err = &smithy.DeserializationError{ 2816 Err: fmt.Errorf("failed to decode response body, %w", err), 2817 Snapshot: snapshot.Bytes(), 2818 } 2819 return err 2820 } 2821 2822 errorBody.Seek(0, io.SeekStart) 2823 if len(code) != 0 { 2824 errorCode = restjson.SanitizeErrorCode(code) 2825 } 2826 if len(message) != 0 { 2827 errorMessage = message 2828 } 2829 2830 switch { 2831 case strings.EqualFold("InternalServiceErrorException", errorCode): 2832 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2833 2834 case strings.EqualFold("InvalidArgumentException", errorCode): 2835 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2836 2837 case strings.EqualFold("ListenerNotFoundException", errorCode): 2838 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 2839 2840 default: 2841 genericError := &smithy.GenericAPIError{ 2842 Code: errorCode, 2843 Message: errorMessage, 2844 } 2845 return genericError 2846 2847 } 2848} 2849 2850type awsAwsjson11_deserializeOpListAccelerators struct { 2851} 2852 2853func (*awsAwsjson11_deserializeOpListAccelerators) ID() string { 2854 return "OperationDeserializer" 2855} 2856 2857func (m *awsAwsjson11_deserializeOpListAccelerators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2858 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2859) { 2860 out, metadata, err = next.HandleDeserialize(ctx, in) 2861 if err != nil { 2862 return out, metadata, err 2863 } 2864 2865 response, ok := out.RawResponse.(*smithyhttp.Response) 2866 if !ok { 2867 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2868 } 2869 2870 if response.StatusCode < 200 || response.StatusCode >= 300 { 2871 return out, metadata, awsAwsjson11_deserializeOpErrorListAccelerators(response, &metadata) 2872 } 2873 output := &ListAcceleratorsOutput{} 2874 out.Result = output 2875 2876 var buff [1024]byte 2877 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2878 2879 body := io.TeeReader(response.Body, ringBuffer) 2880 decoder := json.NewDecoder(body) 2881 decoder.UseNumber() 2882 var shape interface{} 2883 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2884 var snapshot bytes.Buffer 2885 io.Copy(&snapshot, ringBuffer) 2886 err = &smithy.DeserializationError{ 2887 Err: fmt.Errorf("failed to decode response body, %w", err), 2888 Snapshot: snapshot.Bytes(), 2889 } 2890 return out, metadata, err 2891 } 2892 2893 err = awsAwsjson11_deserializeOpDocumentListAcceleratorsOutput(&output, shape) 2894 if err != nil { 2895 var snapshot bytes.Buffer 2896 io.Copy(&snapshot, ringBuffer) 2897 err = &smithy.DeserializationError{ 2898 Err: fmt.Errorf("failed to decode response body, %w", err), 2899 Snapshot: snapshot.Bytes(), 2900 } 2901 return out, metadata, err 2902 } 2903 2904 return out, metadata, err 2905} 2906 2907func awsAwsjson11_deserializeOpErrorListAccelerators(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2908 var errorBuffer bytes.Buffer 2909 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2910 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2911 } 2912 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2913 2914 errorCode := "UnknownError" 2915 errorMessage := errorCode 2916 2917 code := response.Header.Get("X-Amzn-ErrorType") 2918 if len(code) != 0 { 2919 errorCode = restjson.SanitizeErrorCode(code) 2920 } 2921 2922 var buff [1024]byte 2923 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2924 2925 body := io.TeeReader(errorBody, ringBuffer) 2926 decoder := json.NewDecoder(body) 2927 decoder.UseNumber() 2928 code, message, err := restjson.GetErrorInfo(decoder) 2929 if err != nil { 2930 var snapshot bytes.Buffer 2931 io.Copy(&snapshot, ringBuffer) 2932 err = &smithy.DeserializationError{ 2933 Err: fmt.Errorf("failed to decode response body, %w", err), 2934 Snapshot: snapshot.Bytes(), 2935 } 2936 return err 2937 } 2938 2939 errorBody.Seek(0, io.SeekStart) 2940 if len(code) != 0 { 2941 errorCode = restjson.SanitizeErrorCode(code) 2942 } 2943 if len(message) != 0 { 2944 errorMessage = message 2945 } 2946 2947 switch { 2948 case strings.EqualFold("InternalServiceErrorException", errorCode): 2949 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 2950 2951 case strings.EqualFold("InvalidArgumentException", errorCode): 2952 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 2953 2954 case strings.EqualFold("InvalidNextTokenException", errorCode): 2955 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2956 2957 default: 2958 genericError := &smithy.GenericAPIError{ 2959 Code: errorCode, 2960 Message: errorMessage, 2961 } 2962 return genericError 2963 2964 } 2965} 2966 2967type awsAwsjson11_deserializeOpListByoipCidrs struct { 2968} 2969 2970func (*awsAwsjson11_deserializeOpListByoipCidrs) ID() string { 2971 return "OperationDeserializer" 2972} 2973 2974func (m *awsAwsjson11_deserializeOpListByoipCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2975 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2976) { 2977 out, metadata, err = next.HandleDeserialize(ctx, in) 2978 if err != nil { 2979 return out, metadata, err 2980 } 2981 2982 response, ok := out.RawResponse.(*smithyhttp.Response) 2983 if !ok { 2984 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2985 } 2986 2987 if response.StatusCode < 200 || response.StatusCode >= 300 { 2988 return out, metadata, awsAwsjson11_deserializeOpErrorListByoipCidrs(response, &metadata) 2989 } 2990 output := &ListByoipCidrsOutput{} 2991 out.Result = output 2992 2993 var buff [1024]byte 2994 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2995 2996 body := io.TeeReader(response.Body, ringBuffer) 2997 decoder := json.NewDecoder(body) 2998 decoder.UseNumber() 2999 var shape interface{} 3000 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3001 var snapshot bytes.Buffer 3002 io.Copy(&snapshot, ringBuffer) 3003 err = &smithy.DeserializationError{ 3004 Err: fmt.Errorf("failed to decode response body, %w", err), 3005 Snapshot: snapshot.Bytes(), 3006 } 3007 return out, metadata, err 3008 } 3009 3010 err = awsAwsjson11_deserializeOpDocumentListByoipCidrsOutput(&output, shape) 3011 if err != nil { 3012 var snapshot bytes.Buffer 3013 io.Copy(&snapshot, ringBuffer) 3014 err = &smithy.DeserializationError{ 3015 Err: fmt.Errorf("failed to decode response body, %w", err), 3016 Snapshot: snapshot.Bytes(), 3017 } 3018 return out, metadata, err 3019 } 3020 3021 return out, metadata, err 3022} 3023 3024func awsAwsjson11_deserializeOpErrorListByoipCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3025 var errorBuffer bytes.Buffer 3026 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3027 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3028 } 3029 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3030 3031 errorCode := "UnknownError" 3032 errorMessage := errorCode 3033 3034 code := response.Header.Get("X-Amzn-ErrorType") 3035 if len(code) != 0 { 3036 errorCode = restjson.SanitizeErrorCode(code) 3037 } 3038 3039 var buff [1024]byte 3040 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3041 3042 body := io.TeeReader(errorBody, ringBuffer) 3043 decoder := json.NewDecoder(body) 3044 decoder.UseNumber() 3045 code, message, err := restjson.GetErrorInfo(decoder) 3046 if err != nil { 3047 var snapshot bytes.Buffer 3048 io.Copy(&snapshot, ringBuffer) 3049 err = &smithy.DeserializationError{ 3050 Err: fmt.Errorf("failed to decode response body, %w", err), 3051 Snapshot: snapshot.Bytes(), 3052 } 3053 return err 3054 } 3055 3056 errorBody.Seek(0, io.SeekStart) 3057 if len(code) != 0 { 3058 errorCode = restjson.SanitizeErrorCode(code) 3059 } 3060 if len(message) != 0 { 3061 errorMessage = message 3062 } 3063 3064 switch { 3065 case strings.EqualFold("AccessDeniedException", errorCode): 3066 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3067 3068 case strings.EqualFold("InternalServiceErrorException", errorCode): 3069 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3070 3071 case strings.EqualFold("InvalidArgumentException", errorCode): 3072 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3073 3074 case strings.EqualFold("InvalidNextTokenException", errorCode): 3075 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3076 3077 default: 3078 genericError := &smithy.GenericAPIError{ 3079 Code: errorCode, 3080 Message: errorMessage, 3081 } 3082 return genericError 3083 3084 } 3085} 3086 3087type awsAwsjson11_deserializeOpListCustomRoutingAccelerators struct { 3088} 3089 3090func (*awsAwsjson11_deserializeOpListCustomRoutingAccelerators) ID() string { 3091 return "OperationDeserializer" 3092} 3093 3094func (m *awsAwsjson11_deserializeOpListCustomRoutingAccelerators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3096) { 3097 out, metadata, err = next.HandleDeserialize(ctx, in) 3098 if err != nil { 3099 return out, metadata, err 3100 } 3101 3102 response, ok := out.RawResponse.(*smithyhttp.Response) 3103 if !ok { 3104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3105 } 3106 3107 if response.StatusCode < 200 || response.StatusCode >= 300 { 3108 return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingAccelerators(response, &metadata) 3109 } 3110 output := &ListCustomRoutingAcceleratorsOutput{} 3111 out.Result = output 3112 3113 var buff [1024]byte 3114 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3115 3116 body := io.TeeReader(response.Body, ringBuffer) 3117 decoder := json.NewDecoder(body) 3118 decoder.UseNumber() 3119 var shape interface{} 3120 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3121 var snapshot bytes.Buffer 3122 io.Copy(&snapshot, ringBuffer) 3123 err = &smithy.DeserializationError{ 3124 Err: fmt.Errorf("failed to decode response body, %w", err), 3125 Snapshot: snapshot.Bytes(), 3126 } 3127 return out, metadata, err 3128 } 3129 3130 err = awsAwsjson11_deserializeOpDocumentListCustomRoutingAcceleratorsOutput(&output, shape) 3131 if err != nil { 3132 var snapshot bytes.Buffer 3133 io.Copy(&snapshot, ringBuffer) 3134 err = &smithy.DeserializationError{ 3135 Err: fmt.Errorf("failed to decode response body, %w", err), 3136 Snapshot: snapshot.Bytes(), 3137 } 3138 return out, metadata, err 3139 } 3140 3141 return out, metadata, err 3142} 3143 3144func awsAwsjson11_deserializeOpErrorListCustomRoutingAccelerators(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3145 var errorBuffer bytes.Buffer 3146 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3147 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3148 } 3149 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3150 3151 errorCode := "UnknownError" 3152 errorMessage := errorCode 3153 3154 code := response.Header.Get("X-Amzn-ErrorType") 3155 if len(code) != 0 { 3156 errorCode = restjson.SanitizeErrorCode(code) 3157 } 3158 3159 var buff [1024]byte 3160 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3161 3162 body := io.TeeReader(errorBody, ringBuffer) 3163 decoder := json.NewDecoder(body) 3164 decoder.UseNumber() 3165 code, message, err := restjson.GetErrorInfo(decoder) 3166 if err != nil { 3167 var snapshot bytes.Buffer 3168 io.Copy(&snapshot, ringBuffer) 3169 err = &smithy.DeserializationError{ 3170 Err: fmt.Errorf("failed to decode response body, %w", err), 3171 Snapshot: snapshot.Bytes(), 3172 } 3173 return err 3174 } 3175 3176 errorBody.Seek(0, io.SeekStart) 3177 if len(code) != 0 { 3178 errorCode = restjson.SanitizeErrorCode(code) 3179 } 3180 if len(message) != 0 { 3181 errorMessage = message 3182 } 3183 3184 switch { 3185 case strings.EqualFold("InternalServiceErrorException", errorCode): 3186 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3187 3188 case strings.EqualFold("InvalidArgumentException", errorCode): 3189 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3190 3191 case strings.EqualFold("InvalidNextTokenException", errorCode): 3192 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3193 3194 default: 3195 genericError := &smithy.GenericAPIError{ 3196 Code: errorCode, 3197 Message: errorMessage, 3198 } 3199 return genericError 3200 3201 } 3202} 3203 3204type awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups struct { 3205} 3206 3207func (*awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups) ID() string { 3208 return "OperationDeserializer" 3209} 3210 3211func (m *awsAwsjson11_deserializeOpListCustomRoutingEndpointGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3212 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3213) { 3214 out, metadata, err = next.HandleDeserialize(ctx, in) 3215 if err != nil { 3216 return out, metadata, err 3217 } 3218 3219 response, ok := out.RawResponse.(*smithyhttp.Response) 3220 if !ok { 3221 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3222 } 3223 3224 if response.StatusCode < 200 || response.StatusCode >= 300 { 3225 return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingEndpointGroups(response, &metadata) 3226 } 3227 output := &ListCustomRoutingEndpointGroupsOutput{} 3228 out.Result = output 3229 3230 var buff [1024]byte 3231 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3232 3233 body := io.TeeReader(response.Body, ringBuffer) 3234 decoder := json.NewDecoder(body) 3235 decoder.UseNumber() 3236 var shape interface{} 3237 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3238 var snapshot bytes.Buffer 3239 io.Copy(&snapshot, ringBuffer) 3240 err = &smithy.DeserializationError{ 3241 Err: fmt.Errorf("failed to decode response body, %w", err), 3242 Snapshot: snapshot.Bytes(), 3243 } 3244 return out, metadata, err 3245 } 3246 3247 err = awsAwsjson11_deserializeOpDocumentListCustomRoutingEndpointGroupsOutput(&output, shape) 3248 if err != nil { 3249 var snapshot bytes.Buffer 3250 io.Copy(&snapshot, ringBuffer) 3251 err = &smithy.DeserializationError{ 3252 Err: fmt.Errorf("failed to decode response body, %w", err), 3253 Snapshot: snapshot.Bytes(), 3254 } 3255 return out, metadata, err 3256 } 3257 3258 return out, metadata, err 3259} 3260 3261func awsAwsjson11_deserializeOpErrorListCustomRoutingEndpointGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3262 var errorBuffer bytes.Buffer 3263 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3264 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3265 } 3266 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3267 3268 errorCode := "UnknownError" 3269 errorMessage := errorCode 3270 3271 code := response.Header.Get("X-Amzn-ErrorType") 3272 if len(code) != 0 { 3273 errorCode = restjson.SanitizeErrorCode(code) 3274 } 3275 3276 var buff [1024]byte 3277 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3278 3279 body := io.TeeReader(errorBody, ringBuffer) 3280 decoder := json.NewDecoder(body) 3281 decoder.UseNumber() 3282 code, message, err := restjson.GetErrorInfo(decoder) 3283 if err != nil { 3284 var snapshot bytes.Buffer 3285 io.Copy(&snapshot, ringBuffer) 3286 err = &smithy.DeserializationError{ 3287 Err: fmt.Errorf("failed to decode response body, %w", err), 3288 Snapshot: snapshot.Bytes(), 3289 } 3290 return err 3291 } 3292 3293 errorBody.Seek(0, io.SeekStart) 3294 if len(code) != 0 { 3295 errorCode = restjson.SanitizeErrorCode(code) 3296 } 3297 if len(message) != 0 { 3298 errorMessage = message 3299 } 3300 3301 switch { 3302 case strings.EqualFold("InternalServiceErrorException", errorCode): 3303 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3304 3305 case strings.EqualFold("InvalidArgumentException", errorCode): 3306 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3307 3308 case strings.EqualFold("InvalidNextTokenException", errorCode): 3309 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3310 3311 case strings.EqualFold("ListenerNotFoundException", errorCode): 3312 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 3313 3314 default: 3315 genericError := &smithy.GenericAPIError{ 3316 Code: errorCode, 3317 Message: errorMessage, 3318 } 3319 return genericError 3320 3321 } 3322} 3323 3324type awsAwsjson11_deserializeOpListCustomRoutingListeners struct { 3325} 3326 3327func (*awsAwsjson11_deserializeOpListCustomRoutingListeners) ID() string { 3328 return "OperationDeserializer" 3329} 3330 3331func (m *awsAwsjson11_deserializeOpListCustomRoutingListeners) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3332 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3333) { 3334 out, metadata, err = next.HandleDeserialize(ctx, in) 3335 if err != nil { 3336 return out, metadata, err 3337 } 3338 3339 response, ok := out.RawResponse.(*smithyhttp.Response) 3340 if !ok { 3341 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3342 } 3343 3344 if response.StatusCode < 200 || response.StatusCode >= 300 { 3345 return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingListeners(response, &metadata) 3346 } 3347 output := &ListCustomRoutingListenersOutput{} 3348 out.Result = output 3349 3350 var buff [1024]byte 3351 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3352 3353 body := io.TeeReader(response.Body, ringBuffer) 3354 decoder := json.NewDecoder(body) 3355 decoder.UseNumber() 3356 var shape interface{} 3357 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3358 var snapshot bytes.Buffer 3359 io.Copy(&snapshot, ringBuffer) 3360 err = &smithy.DeserializationError{ 3361 Err: fmt.Errorf("failed to decode response body, %w", err), 3362 Snapshot: snapshot.Bytes(), 3363 } 3364 return out, metadata, err 3365 } 3366 3367 err = awsAwsjson11_deserializeOpDocumentListCustomRoutingListenersOutput(&output, shape) 3368 if err != nil { 3369 var snapshot bytes.Buffer 3370 io.Copy(&snapshot, ringBuffer) 3371 err = &smithy.DeserializationError{ 3372 Err: fmt.Errorf("failed to decode response body, %w", err), 3373 Snapshot: snapshot.Bytes(), 3374 } 3375 return out, metadata, err 3376 } 3377 3378 return out, metadata, err 3379} 3380 3381func awsAwsjson11_deserializeOpErrorListCustomRoutingListeners(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3382 var errorBuffer bytes.Buffer 3383 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3384 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3385 } 3386 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3387 3388 errorCode := "UnknownError" 3389 errorMessage := errorCode 3390 3391 code := response.Header.Get("X-Amzn-ErrorType") 3392 if len(code) != 0 { 3393 errorCode = restjson.SanitizeErrorCode(code) 3394 } 3395 3396 var buff [1024]byte 3397 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3398 3399 body := io.TeeReader(errorBody, ringBuffer) 3400 decoder := json.NewDecoder(body) 3401 decoder.UseNumber() 3402 code, message, err := restjson.GetErrorInfo(decoder) 3403 if err != nil { 3404 var snapshot bytes.Buffer 3405 io.Copy(&snapshot, ringBuffer) 3406 err = &smithy.DeserializationError{ 3407 Err: fmt.Errorf("failed to decode response body, %w", err), 3408 Snapshot: snapshot.Bytes(), 3409 } 3410 return err 3411 } 3412 3413 errorBody.Seek(0, io.SeekStart) 3414 if len(code) != 0 { 3415 errorCode = restjson.SanitizeErrorCode(code) 3416 } 3417 if len(message) != 0 { 3418 errorMessage = message 3419 } 3420 3421 switch { 3422 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 3423 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 3424 3425 case strings.EqualFold("InternalServiceErrorException", errorCode): 3426 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3427 3428 case strings.EqualFold("InvalidArgumentException", errorCode): 3429 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3430 3431 case strings.EqualFold("InvalidNextTokenException", errorCode): 3432 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3433 3434 default: 3435 genericError := &smithy.GenericAPIError{ 3436 Code: errorCode, 3437 Message: errorMessage, 3438 } 3439 return genericError 3440 3441 } 3442} 3443 3444type awsAwsjson11_deserializeOpListCustomRoutingPortMappings struct { 3445} 3446 3447func (*awsAwsjson11_deserializeOpListCustomRoutingPortMappings) ID() string { 3448 return "OperationDeserializer" 3449} 3450 3451func (m *awsAwsjson11_deserializeOpListCustomRoutingPortMappings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3452 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3453) { 3454 out, metadata, err = next.HandleDeserialize(ctx, in) 3455 if err != nil { 3456 return out, metadata, err 3457 } 3458 3459 response, ok := out.RawResponse.(*smithyhttp.Response) 3460 if !ok { 3461 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3462 } 3463 3464 if response.StatusCode < 200 || response.StatusCode >= 300 { 3465 return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappings(response, &metadata) 3466 } 3467 output := &ListCustomRoutingPortMappingsOutput{} 3468 out.Result = output 3469 3470 var buff [1024]byte 3471 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3472 3473 body := io.TeeReader(response.Body, ringBuffer) 3474 decoder := json.NewDecoder(body) 3475 decoder.UseNumber() 3476 var shape interface{} 3477 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3478 var snapshot bytes.Buffer 3479 io.Copy(&snapshot, ringBuffer) 3480 err = &smithy.DeserializationError{ 3481 Err: fmt.Errorf("failed to decode response body, %w", err), 3482 Snapshot: snapshot.Bytes(), 3483 } 3484 return out, metadata, err 3485 } 3486 3487 err = awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsOutput(&output, shape) 3488 if err != nil { 3489 var snapshot bytes.Buffer 3490 io.Copy(&snapshot, ringBuffer) 3491 err = &smithy.DeserializationError{ 3492 Err: fmt.Errorf("failed to decode response body, %w", err), 3493 Snapshot: snapshot.Bytes(), 3494 } 3495 return out, metadata, err 3496 } 3497 3498 return out, metadata, err 3499} 3500 3501func awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3502 var errorBuffer bytes.Buffer 3503 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3504 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3505 } 3506 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3507 3508 errorCode := "UnknownError" 3509 errorMessage := errorCode 3510 3511 code := response.Header.Get("X-Amzn-ErrorType") 3512 if len(code) != 0 { 3513 errorCode = restjson.SanitizeErrorCode(code) 3514 } 3515 3516 var buff [1024]byte 3517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3518 3519 body := io.TeeReader(errorBody, ringBuffer) 3520 decoder := json.NewDecoder(body) 3521 decoder.UseNumber() 3522 code, message, err := restjson.GetErrorInfo(decoder) 3523 if err != nil { 3524 var snapshot bytes.Buffer 3525 io.Copy(&snapshot, ringBuffer) 3526 err = &smithy.DeserializationError{ 3527 Err: fmt.Errorf("failed to decode response body, %w", err), 3528 Snapshot: snapshot.Bytes(), 3529 } 3530 return err 3531 } 3532 3533 errorBody.Seek(0, io.SeekStart) 3534 if len(code) != 0 { 3535 errorCode = restjson.SanitizeErrorCode(code) 3536 } 3537 if len(message) != 0 { 3538 errorMessage = message 3539 } 3540 3541 switch { 3542 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 3543 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 3544 3545 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 3546 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 3547 3548 case strings.EqualFold("InternalServiceErrorException", errorCode): 3549 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3550 3551 case strings.EqualFold("InvalidArgumentException", errorCode): 3552 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3553 3554 case strings.EqualFold("InvalidNextTokenException", errorCode): 3555 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3556 3557 default: 3558 genericError := &smithy.GenericAPIError{ 3559 Code: errorCode, 3560 Message: errorMessage, 3561 } 3562 return genericError 3563 3564 } 3565} 3566 3567type awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination struct { 3568} 3569 3570func (*awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination) ID() string { 3571 return "OperationDeserializer" 3572} 3573 3574func (m *awsAwsjson11_deserializeOpListCustomRoutingPortMappingsByDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3575 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3576) { 3577 out, metadata, err = next.HandleDeserialize(ctx, in) 3578 if err != nil { 3579 return out, metadata, err 3580 } 3581 3582 response, ok := out.RawResponse.(*smithyhttp.Response) 3583 if !ok { 3584 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3585 } 3586 3587 if response.StatusCode < 200 || response.StatusCode >= 300 { 3588 return out, metadata, awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappingsByDestination(response, &metadata) 3589 } 3590 output := &ListCustomRoutingPortMappingsByDestinationOutput{} 3591 out.Result = output 3592 3593 var buff [1024]byte 3594 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3595 3596 body := io.TeeReader(response.Body, ringBuffer) 3597 decoder := json.NewDecoder(body) 3598 decoder.UseNumber() 3599 var shape interface{} 3600 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3601 var snapshot bytes.Buffer 3602 io.Copy(&snapshot, ringBuffer) 3603 err = &smithy.DeserializationError{ 3604 Err: fmt.Errorf("failed to decode response body, %w", err), 3605 Snapshot: snapshot.Bytes(), 3606 } 3607 return out, metadata, err 3608 } 3609 3610 err = awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsByDestinationOutput(&output, shape) 3611 if err != nil { 3612 var snapshot bytes.Buffer 3613 io.Copy(&snapshot, ringBuffer) 3614 err = &smithy.DeserializationError{ 3615 Err: fmt.Errorf("failed to decode response body, %w", err), 3616 Snapshot: snapshot.Bytes(), 3617 } 3618 return out, metadata, err 3619 } 3620 3621 return out, metadata, err 3622} 3623 3624func awsAwsjson11_deserializeOpErrorListCustomRoutingPortMappingsByDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3625 var errorBuffer bytes.Buffer 3626 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3627 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3628 } 3629 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3630 3631 errorCode := "UnknownError" 3632 errorMessage := errorCode 3633 3634 code := response.Header.Get("X-Amzn-ErrorType") 3635 if len(code) != 0 { 3636 errorCode = restjson.SanitizeErrorCode(code) 3637 } 3638 3639 var buff [1024]byte 3640 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3641 3642 body := io.TeeReader(errorBody, ringBuffer) 3643 decoder := json.NewDecoder(body) 3644 decoder.UseNumber() 3645 code, message, err := restjson.GetErrorInfo(decoder) 3646 if err != nil { 3647 var snapshot bytes.Buffer 3648 io.Copy(&snapshot, ringBuffer) 3649 err = &smithy.DeserializationError{ 3650 Err: fmt.Errorf("failed to decode response body, %w", err), 3651 Snapshot: snapshot.Bytes(), 3652 } 3653 return err 3654 } 3655 3656 errorBody.Seek(0, io.SeekStart) 3657 if len(code) != 0 { 3658 errorCode = restjson.SanitizeErrorCode(code) 3659 } 3660 if len(message) != 0 { 3661 errorMessage = message 3662 } 3663 3664 switch { 3665 case strings.EqualFold("EndpointNotFoundException", errorCode): 3666 return awsAwsjson11_deserializeErrorEndpointNotFoundException(response, errorBody) 3667 3668 case strings.EqualFold("InternalServiceErrorException", errorCode): 3669 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3670 3671 case strings.EqualFold("InvalidArgumentException", errorCode): 3672 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3673 3674 case strings.EqualFold("InvalidNextTokenException", errorCode): 3675 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3676 3677 default: 3678 genericError := &smithy.GenericAPIError{ 3679 Code: errorCode, 3680 Message: errorMessage, 3681 } 3682 return genericError 3683 3684 } 3685} 3686 3687type awsAwsjson11_deserializeOpListEndpointGroups struct { 3688} 3689 3690func (*awsAwsjson11_deserializeOpListEndpointGroups) ID() string { 3691 return "OperationDeserializer" 3692} 3693 3694func (m *awsAwsjson11_deserializeOpListEndpointGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3695 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3696) { 3697 out, metadata, err = next.HandleDeserialize(ctx, in) 3698 if err != nil { 3699 return out, metadata, err 3700 } 3701 3702 response, ok := out.RawResponse.(*smithyhttp.Response) 3703 if !ok { 3704 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3705 } 3706 3707 if response.StatusCode < 200 || response.StatusCode >= 300 { 3708 return out, metadata, awsAwsjson11_deserializeOpErrorListEndpointGroups(response, &metadata) 3709 } 3710 output := &ListEndpointGroupsOutput{} 3711 out.Result = output 3712 3713 var buff [1024]byte 3714 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3715 3716 body := io.TeeReader(response.Body, ringBuffer) 3717 decoder := json.NewDecoder(body) 3718 decoder.UseNumber() 3719 var shape interface{} 3720 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3721 var snapshot bytes.Buffer 3722 io.Copy(&snapshot, ringBuffer) 3723 err = &smithy.DeserializationError{ 3724 Err: fmt.Errorf("failed to decode response body, %w", err), 3725 Snapshot: snapshot.Bytes(), 3726 } 3727 return out, metadata, err 3728 } 3729 3730 err = awsAwsjson11_deserializeOpDocumentListEndpointGroupsOutput(&output, shape) 3731 if err != nil { 3732 var snapshot bytes.Buffer 3733 io.Copy(&snapshot, ringBuffer) 3734 err = &smithy.DeserializationError{ 3735 Err: fmt.Errorf("failed to decode response body, %w", err), 3736 Snapshot: snapshot.Bytes(), 3737 } 3738 return out, metadata, err 3739 } 3740 3741 return out, metadata, err 3742} 3743 3744func awsAwsjson11_deserializeOpErrorListEndpointGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3745 var errorBuffer bytes.Buffer 3746 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3747 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3748 } 3749 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3750 3751 errorCode := "UnknownError" 3752 errorMessage := errorCode 3753 3754 code := response.Header.Get("X-Amzn-ErrorType") 3755 if len(code) != 0 { 3756 errorCode = restjson.SanitizeErrorCode(code) 3757 } 3758 3759 var buff [1024]byte 3760 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3761 3762 body := io.TeeReader(errorBody, ringBuffer) 3763 decoder := json.NewDecoder(body) 3764 decoder.UseNumber() 3765 code, message, err := restjson.GetErrorInfo(decoder) 3766 if err != nil { 3767 var snapshot bytes.Buffer 3768 io.Copy(&snapshot, ringBuffer) 3769 err = &smithy.DeserializationError{ 3770 Err: fmt.Errorf("failed to decode response body, %w", err), 3771 Snapshot: snapshot.Bytes(), 3772 } 3773 return err 3774 } 3775 3776 errorBody.Seek(0, io.SeekStart) 3777 if len(code) != 0 { 3778 errorCode = restjson.SanitizeErrorCode(code) 3779 } 3780 if len(message) != 0 { 3781 errorMessage = message 3782 } 3783 3784 switch { 3785 case strings.EqualFold("InternalServiceErrorException", errorCode): 3786 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3787 3788 case strings.EqualFold("InvalidArgumentException", errorCode): 3789 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3790 3791 case strings.EqualFold("InvalidNextTokenException", errorCode): 3792 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3793 3794 case strings.EqualFold("ListenerNotFoundException", errorCode): 3795 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 3796 3797 default: 3798 genericError := &smithy.GenericAPIError{ 3799 Code: errorCode, 3800 Message: errorMessage, 3801 } 3802 return genericError 3803 3804 } 3805} 3806 3807type awsAwsjson11_deserializeOpListListeners struct { 3808} 3809 3810func (*awsAwsjson11_deserializeOpListListeners) ID() string { 3811 return "OperationDeserializer" 3812} 3813 3814func (m *awsAwsjson11_deserializeOpListListeners) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3815 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3816) { 3817 out, metadata, err = next.HandleDeserialize(ctx, in) 3818 if err != nil { 3819 return out, metadata, err 3820 } 3821 3822 response, ok := out.RawResponse.(*smithyhttp.Response) 3823 if !ok { 3824 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3825 } 3826 3827 if response.StatusCode < 200 || response.StatusCode >= 300 { 3828 return out, metadata, awsAwsjson11_deserializeOpErrorListListeners(response, &metadata) 3829 } 3830 output := &ListListenersOutput{} 3831 out.Result = output 3832 3833 var buff [1024]byte 3834 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3835 3836 body := io.TeeReader(response.Body, ringBuffer) 3837 decoder := json.NewDecoder(body) 3838 decoder.UseNumber() 3839 var shape interface{} 3840 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3841 var snapshot bytes.Buffer 3842 io.Copy(&snapshot, ringBuffer) 3843 err = &smithy.DeserializationError{ 3844 Err: fmt.Errorf("failed to decode response body, %w", err), 3845 Snapshot: snapshot.Bytes(), 3846 } 3847 return out, metadata, err 3848 } 3849 3850 err = awsAwsjson11_deserializeOpDocumentListListenersOutput(&output, shape) 3851 if err != nil { 3852 var snapshot bytes.Buffer 3853 io.Copy(&snapshot, ringBuffer) 3854 err = &smithy.DeserializationError{ 3855 Err: fmt.Errorf("failed to decode response body, %w", err), 3856 Snapshot: snapshot.Bytes(), 3857 } 3858 return out, metadata, err 3859 } 3860 3861 return out, metadata, err 3862} 3863 3864func awsAwsjson11_deserializeOpErrorListListeners(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3865 var errorBuffer bytes.Buffer 3866 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3867 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3868 } 3869 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3870 3871 errorCode := "UnknownError" 3872 errorMessage := errorCode 3873 3874 code := response.Header.Get("X-Amzn-ErrorType") 3875 if len(code) != 0 { 3876 errorCode = restjson.SanitizeErrorCode(code) 3877 } 3878 3879 var buff [1024]byte 3880 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3881 3882 body := io.TeeReader(errorBody, ringBuffer) 3883 decoder := json.NewDecoder(body) 3884 decoder.UseNumber() 3885 code, message, err := restjson.GetErrorInfo(decoder) 3886 if err != nil { 3887 var snapshot bytes.Buffer 3888 io.Copy(&snapshot, ringBuffer) 3889 err = &smithy.DeserializationError{ 3890 Err: fmt.Errorf("failed to decode response body, %w", err), 3891 Snapshot: snapshot.Bytes(), 3892 } 3893 return err 3894 } 3895 3896 errorBody.Seek(0, io.SeekStart) 3897 if len(code) != 0 { 3898 errorCode = restjson.SanitizeErrorCode(code) 3899 } 3900 if len(message) != 0 { 3901 errorMessage = message 3902 } 3903 3904 switch { 3905 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 3906 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 3907 3908 case strings.EqualFold("InternalServiceErrorException", errorCode): 3909 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 3910 3911 case strings.EqualFold("InvalidArgumentException", errorCode): 3912 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 3913 3914 case strings.EqualFold("InvalidNextTokenException", errorCode): 3915 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 3916 3917 default: 3918 genericError := &smithy.GenericAPIError{ 3919 Code: errorCode, 3920 Message: errorMessage, 3921 } 3922 return genericError 3923 3924 } 3925} 3926 3927type awsAwsjson11_deserializeOpListTagsForResource struct { 3928} 3929 3930func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 3931 return "OperationDeserializer" 3932} 3933 3934func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3935 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3936) { 3937 out, metadata, err = next.HandleDeserialize(ctx, in) 3938 if err != nil { 3939 return out, metadata, err 3940 } 3941 3942 response, ok := out.RawResponse.(*smithyhttp.Response) 3943 if !ok { 3944 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3945 } 3946 3947 if response.StatusCode < 200 || response.StatusCode >= 300 { 3948 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 3949 } 3950 output := &ListTagsForResourceOutput{} 3951 out.Result = output 3952 3953 var buff [1024]byte 3954 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3955 3956 body := io.TeeReader(response.Body, ringBuffer) 3957 decoder := json.NewDecoder(body) 3958 decoder.UseNumber() 3959 var shape interface{} 3960 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3961 var snapshot bytes.Buffer 3962 io.Copy(&snapshot, ringBuffer) 3963 err = &smithy.DeserializationError{ 3964 Err: fmt.Errorf("failed to decode response body, %w", err), 3965 Snapshot: snapshot.Bytes(), 3966 } 3967 return out, metadata, err 3968 } 3969 3970 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 3971 if err != nil { 3972 var snapshot bytes.Buffer 3973 io.Copy(&snapshot, ringBuffer) 3974 err = &smithy.DeserializationError{ 3975 Err: fmt.Errorf("failed to decode response body, %w", err), 3976 Snapshot: snapshot.Bytes(), 3977 } 3978 return out, metadata, err 3979 } 3980 3981 return out, metadata, err 3982} 3983 3984func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3985 var errorBuffer bytes.Buffer 3986 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3987 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3988 } 3989 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3990 3991 errorCode := "UnknownError" 3992 errorMessage := errorCode 3993 3994 code := response.Header.Get("X-Amzn-ErrorType") 3995 if len(code) != 0 { 3996 errorCode = restjson.SanitizeErrorCode(code) 3997 } 3998 3999 var buff [1024]byte 4000 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4001 4002 body := io.TeeReader(errorBody, ringBuffer) 4003 decoder := json.NewDecoder(body) 4004 decoder.UseNumber() 4005 code, message, err := restjson.GetErrorInfo(decoder) 4006 if err != nil { 4007 var snapshot bytes.Buffer 4008 io.Copy(&snapshot, ringBuffer) 4009 err = &smithy.DeserializationError{ 4010 Err: fmt.Errorf("failed to decode response body, %w", err), 4011 Snapshot: snapshot.Bytes(), 4012 } 4013 return err 4014 } 4015 4016 errorBody.Seek(0, io.SeekStart) 4017 if len(code) != 0 { 4018 errorCode = restjson.SanitizeErrorCode(code) 4019 } 4020 if len(message) != 0 { 4021 errorMessage = message 4022 } 4023 4024 switch { 4025 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4026 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4027 4028 case strings.EqualFold("InternalServiceErrorException", errorCode): 4029 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4030 4031 case strings.EqualFold("InvalidArgumentException", errorCode): 4032 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4033 4034 default: 4035 genericError := &smithy.GenericAPIError{ 4036 Code: errorCode, 4037 Message: errorMessage, 4038 } 4039 return genericError 4040 4041 } 4042} 4043 4044type awsAwsjson11_deserializeOpProvisionByoipCidr struct { 4045} 4046 4047func (*awsAwsjson11_deserializeOpProvisionByoipCidr) ID() string { 4048 return "OperationDeserializer" 4049} 4050 4051func (m *awsAwsjson11_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4052 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4053) { 4054 out, metadata, err = next.HandleDeserialize(ctx, in) 4055 if err != nil { 4056 return out, metadata, err 4057 } 4058 4059 response, ok := out.RawResponse.(*smithyhttp.Response) 4060 if !ok { 4061 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4062 } 4063 4064 if response.StatusCode < 200 || response.StatusCode >= 300 { 4065 return out, metadata, awsAwsjson11_deserializeOpErrorProvisionByoipCidr(response, &metadata) 4066 } 4067 output := &ProvisionByoipCidrOutput{} 4068 out.Result = output 4069 4070 var buff [1024]byte 4071 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4072 4073 body := io.TeeReader(response.Body, ringBuffer) 4074 decoder := json.NewDecoder(body) 4075 decoder.UseNumber() 4076 var shape interface{} 4077 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4078 var snapshot bytes.Buffer 4079 io.Copy(&snapshot, ringBuffer) 4080 err = &smithy.DeserializationError{ 4081 Err: fmt.Errorf("failed to decode response body, %w", err), 4082 Snapshot: snapshot.Bytes(), 4083 } 4084 return out, metadata, err 4085 } 4086 4087 err = awsAwsjson11_deserializeOpDocumentProvisionByoipCidrOutput(&output, shape) 4088 if err != nil { 4089 var snapshot bytes.Buffer 4090 io.Copy(&snapshot, ringBuffer) 4091 err = &smithy.DeserializationError{ 4092 Err: fmt.Errorf("failed to decode response body, %w", err), 4093 Snapshot: snapshot.Bytes(), 4094 } 4095 return out, metadata, err 4096 } 4097 4098 return out, metadata, err 4099} 4100 4101func awsAwsjson11_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4102 var errorBuffer bytes.Buffer 4103 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4104 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4105 } 4106 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4107 4108 errorCode := "UnknownError" 4109 errorMessage := errorCode 4110 4111 code := response.Header.Get("X-Amzn-ErrorType") 4112 if len(code) != 0 { 4113 errorCode = restjson.SanitizeErrorCode(code) 4114 } 4115 4116 var buff [1024]byte 4117 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4118 4119 body := io.TeeReader(errorBody, ringBuffer) 4120 decoder := json.NewDecoder(body) 4121 decoder.UseNumber() 4122 code, message, err := restjson.GetErrorInfo(decoder) 4123 if err != nil { 4124 var snapshot bytes.Buffer 4125 io.Copy(&snapshot, ringBuffer) 4126 err = &smithy.DeserializationError{ 4127 Err: fmt.Errorf("failed to decode response body, %w", err), 4128 Snapshot: snapshot.Bytes(), 4129 } 4130 return err 4131 } 4132 4133 errorBody.Seek(0, io.SeekStart) 4134 if len(code) != 0 { 4135 errorCode = restjson.SanitizeErrorCode(code) 4136 } 4137 if len(message) != 0 { 4138 errorMessage = message 4139 } 4140 4141 switch { 4142 case strings.EqualFold("AccessDeniedException", errorCode): 4143 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4144 4145 case strings.EqualFold("IncorrectCidrStateException", errorCode): 4146 return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody) 4147 4148 case strings.EqualFold("InternalServiceErrorException", errorCode): 4149 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4150 4151 case strings.EqualFold("InvalidArgumentException", errorCode): 4152 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4153 4154 case strings.EqualFold("LimitExceededException", errorCode): 4155 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4156 4157 default: 4158 genericError := &smithy.GenericAPIError{ 4159 Code: errorCode, 4160 Message: errorMessage, 4161 } 4162 return genericError 4163 4164 } 4165} 4166 4167type awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints struct { 4168} 4169 4170func (*awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints) ID() string { 4171 return "OperationDeserializer" 4172} 4173 4174func (m *awsAwsjson11_deserializeOpRemoveCustomRoutingEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4175 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4176) { 4177 out, metadata, err = next.HandleDeserialize(ctx, in) 4178 if err != nil { 4179 return out, metadata, err 4180 } 4181 4182 response, ok := out.RawResponse.(*smithyhttp.Response) 4183 if !ok { 4184 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4185 } 4186 4187 if response.StatusCode < 200 || response.StatusCode >= 300 { 4188 return out, metadata, awsAwsjson11_deserializeOpErrorRemoveCustomRoutingEndpoints(response, &metadata) 4189 } 4190 output := &RemoveCustomRoutingEndpointsOutput{} 4191 out.Result = output 4192 4193 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 4194 return out, metadata, &smithy.DeserializationError{ 4195 Err: fmt.Errorf("failed to discard response body, %w", err), 4196 } 4197 } 4198 4199 return out, metadata, err 4200} 4201 4202func awsAwsjson11_deserializeOpErrorRemoveCustomRoutingEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4203 var errorBuffer bytes.Buffer 4204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4206 } 4207 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4208 4209 errorCode := "UnknownError" 4210 errorMessage := errorCode 4211 4212 code := response.Header.Get("X-Amzn-ErrorType") 4213 if len(code) != 0 { 4214 errorCode = restjson.SanitizeErrorCode(code) 4215 } 4216 4217 var buff [1024]byte 4218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4219 4220 body := io.TeeReader(errorBody, ringBuffer) 4221 decoder := json.NewDecoder(body) 4222 decoder.UseNumber() 4223 code, message, err := restjson.GetErrorInfo(decoder) 4224 if err != nil { 4225 var snapshot bytes.Buffer 4226 io.Copy(&snapshot, ringBuffer) 4227 err = &smithy.DeserializationError{ 4228 Err: fmt.Errorf("failed to decode response body, %w", err), 4229 Snapshot: snapshot.Bytes(), 4230 } 4231 return err 4232 } 4233 4234 errorBody.Seek(0, io.SeekStart) 4235 if len(code) != 0 { 4236 errorCode = restjson.SanitizeErrorCode(code) 4237 } 4238 if len(message) != 0 { 4239 errorMessage = message 4240 } 4241 4242 switch { 4243 case strings.EqualFold("AccessDeniedException", errorCode): 4244 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4245 4246 case strings.EqualFold("ConflictException", errorCode): 4247 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 4248 4249 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 4250 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 4251 4252 case strings.EqualFold("EndpointNotFoundException", errorCode): 4253 return awsAwsjson11_deserializeErrorEndpointNotFoundException(response, errorBody) 4254 4255 case strings.EqualFold("InternalServiceErrorException", errorCode): 4256 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4257 4258 case strings.EqualFold("InvalidArgumentException", errorCode): 4259 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4260 4261 default: 4262 genericError := &smithy.GenericAPIError{ 4263 Code: errorCode, 4264 Message: errorMessage, 4265 } 4266 return genericError 4267 4268 } 4269} 4270 4271type awsAwsjson11_deserializeOpTagResource struct { 4272} 4273 4274func (*awsAwsjson11_deserializeOpTagResource) ID() string { 4275 return "OperationDeserializer" 4276} 4277 4278func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4279 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4280) { 4281 out, metadata, err = next.HandleDeserialize(ctx, in) 4282 if err != nil { 4283 return out, metadata, err 4284 } 4285 4286 response, ok := out.RawResponse.(*smithyhttp.Response) 4287 if !ok { 4288 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4289 } 4290 4291 if response.StatusCode < 200 || response.StatusCode >= 300 { 4292 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 4293 } 4294 output := &TagResourceOutput{} 4295 out.Result = output 4296 4297 var buff [1024]byte 4298 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4299 4300 body := io.TeeReader(response.Body, ringBuffer) 4301 decoder := json.NewDecoder(body) 4302 decoder.UseNumber() 4303 var shape interface{} 4304 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4305 var snapshot bytes.Buffer 4306 io.Copy(&snapshot, ringBuffer) 4307 err = &smithy.DeserializationError{ 4308 Err: fmt.Errorf("failed to decode response body, %w", err), 4309 Snapshot: snapshot.Bytes(), 4310 } 4311 return out, metadata, err 4312 } 4313 4314 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 4315 if err != nil { 4316 var snapshot bytes.Buffer 4317 io.Copy(&snapshot, ringBuffer) 4318 err = &smithy.DeserializationError{ 4319 Err: fmt.Errorf("failed to decode response body, %w", err), 4320 Snapshot: snapshot.Bytes(), 4321 } 4322 return out, metadata, err 4323 } 4324 4325 return out, metadata, err 4326} 4327 4328func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4329 var errorBuffer bytes.Buffer 4330 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4331 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4332 } 4333 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4334 4335 errorCode := "UnknownError" 4336 errorMessage := errorCode 4337 4338 code := response.Header.Get("X-Amzn-ErrorType") 4339 if len(code) != 0 { 4340 errorCode = restjson.SanitizeErrorCode(code) 4341 } 4342 4343 var buff [1024]byte 4344 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4345 4346 body := io.TeeReader(errorBody, ringBuffer) 4347 decoder := json.NewDecoder(body) 4348 decoder.UseNumber() 4349 code, message, err := restjson.GetErrorInfo(decoder) 4350 if err != nil { 4351 var snapshot bytes.Buffer 4352 io.Copy(&snapshot, ringBuffer) 4353 err = &smithy.DeserializationError{ 4354 Err: fmt.Errorf("failed to decode response body, %w", err), 4355 Snapshot: snapshot.Bytes(), 4356 } 4357 return err 4358 } 4359 4360 errorBody.Seek(0, io.SeekStart) 4361 if len(code) != 0 { 4362 errorCode = restjson.SanitizeErrorCode(code) 4363 } 4364 if len(message) != 0 { 4365 errorMessage = message 4366 } 4367 4368 switch { 4369 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4370 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4371 4372 case strings.EqualFold("InternalServiceErrorException", errorCode): 4373 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4374 4375 case strings.EqualFold("InvalidArgumentException", errorCode): 4376 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4377 4378 default: 4379 genericError := &smithy.GenericAPIError{ 4380 Code: errorCode, 4381 Message: errorMessage, 4382 } 4383 return genericError 4384 4385 } 4386} 4387 4388type awsAwsjson11_deserializeOpUntagResource struct { 4389} 4390 4391func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 4392 return "OperationDeserializer" 4393} 4394 4395func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4396 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4397) { 4398 out, metadata, err = next.HandleDeserialize(ctx, in) 4399 if err != nil { 4400 return out, metadata, err 4401 } 4402 4403 response, ok := out.RawResponse.(*smithyhttp.Response) 4404 if !ok { 4405 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4406 } 4407 4408 if response.StatusCode < 200 || response.StatusCode >= 300 { 4409 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 4410 } 4411 output := &UntagResourceOutput{} 4412 out.Result = output 4413 4414 var buff [1024]byte 4415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4416 4417 body := io.TeeReader(response.Body, ringBuffer) 4418 decoder := json.NewDecoder(body) 4419 decoder.UseNumber() 4420 var shape interface{} 4421 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 4429 } 4430 4431 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 4432 if err != nil { 4433 var snapshot bytes.Buffer 4434 io.Copy(&snapshot, ringBuffer) 4435 err = &smithy.DeserializationError{ 4436 Err: fmt.Errorf("failed to decode response body, %w", err), 4437 Snapshot: snapshot.Bytes(), 4438 } 4439 return out, metadata, err 4440 } 4441 4442 return out, metadata, err 4443} 4444 4445func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4446 var errorBuffer bytes.Buffer 4447 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4448 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4449 } 4450 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4451 4452 errorCode := "UnknownError" 4453 errorMessage := errorCode 4454 4455 code := response.Header.Get("X-Amzn-ErrorType") 4456 if len(code) != 0 { 4457 errorCode = restjson.SanitizeErrorCode(code) 4458 } 4459 4460 var buff [1024]byte 4461 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4462 4463 body := io.TeeReader(errorBody, ringBuffer) 4464 decoder := json.NewDecoder(body) 4465 decoder.UseNumber() 4466 code, message, err := restjson.GetErrorInfo(decoder) 4467 if err != nil { 4468 var snapshot bytes.Buffer 4469 io.Copy(&snapshot, ringBuffer) 4470 err = &smithy.DeserializationError{ 4471 Err: fmt.Errorf("failed to decode response body, %w", err), 4472 Snapshot: snapshot.Bytes(), 4473 } 4474 return err 4475 } 4476 4477 errorBody.Seek(0, io.SeekStart) 4478 if len(code) != 0 { 4479 errorCode = restjson.SanitizeErrorCode(code) 4480 } 4481 if len(message) != 0 { 4482 errorMessage = message 4483 } 4484 4485 switch { 4486 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4487 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4488 4489 case strings.EqualFold("InternalServiceErrorException", errorCode): 4490 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4491 4492 case strings.EqualFold("InvalidArgumentException", errorCode): 4493 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4494 4495 default: 4496 genericError := &smithy.GenericAPIError{ 4497 Code: errorCode, 4498 Message: errorMessage, 4499 } 4500 return genericError 4501 4502 } 4503} 4504 4505type awsAwsjson11_deserializeOpUpdateAccelerator struct { 4506} 4507 4508func (*awsAwsjson11_deserializeOpUpdateAccelerator) ID() string { 4509 return "OperationDeserializer" 4510} 4511 4512func (m *awsAwsjson11_deserializeOpUpdateAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4513 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4514) { 4515 out, metadata, err = next.HandleDeserialize(ctx, in) 4516 if err != nil { 4517 return out, metadata, err 4518 } 4519 4520 response, ok := out.RawResponse.(*smithyhttp.Response) 4521 if !ok { 4522 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4523 } 4524 4525 if response.StatusCode < 200 || response.StatusCode >= 300 { 4526 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAccelerator(response, &metadata) 4527 } 4528 output := &UpdateAcceleratorOutput{} 4529 out.Result = output 4530 4531 var buff [1024]byte 4532 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4533 4534 body := io.TeeReader(response.Body, ringBuffer) 4535 decoder := json.NewDecoder(body) 4536 decoder.UseNumber() 4537 var shape interface{} 4538 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4539 var snapshot bytes.Buffer 4540 io.Copy(&snapshot, ringBuffer) 4541 err = &smithy.DeserializationError{ 4542 Err: fmt.Errorf("failed to decode response body, %w", err), 4543 Snapshot: snapshot.Bytes(), 4544 } 4545 return out, metadata, err 4546 } 4547 4548 err = awsAwsjson11_deserializeOpDocumentUpdateAcceleratorOutput(&output, shape) 4549 if err != nil { 4550 var snapshot bytes.Buffer 4551 io.Copy(&snapshot, ringBuffer) 4552 err = &smithy.DeserializationError{ 4553 Err: fmt.Errorf("failed to decode response body, %w", err), 4554 Snapshot: snapshot.Bytes(), 4555 } 4556 return out, metadata, err 4557 } 4558 4559 return out, metadata, err 4560} 4561 4562func awsAwsjson11_deserializeOpErrorUpdateAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4563 var errorBuffer bytes.Buffer 4564 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4565 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4566 } 4567 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4568 4569 errorCode := "UnknownError" 4570 errorMessage := errorCode 4571 4572 code := response.Header.Get("X-Amzn-ErrorType") 4573 if len(code) != 0 { 4574 errorCode = restjson.SanitizeErrorCode(code) 4575 } 4576 4577 var buff [1024]byte 4578 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4579 4580 body := io.TeeReader(errorBody, ringBuffer) 4581 decoder := json.NewDecoder(body) 4582 decoder.UseNumber() 4583 code, message, err := restjson.GetErrorInfo(decoder) 4584 if err != nil { 4585 var snapshot bytes.Buffer 4586 io.Copy(&snapshot, ringBuffer) 4587 err = &smithy.DeserializationError{ 4588 Err: fmt.Errorf("failed to decode response body, %w", err), 4589 Snapshot: snapshot.Bytes(), 4590 } 4591 return err 4592 } 4593 4594 errorBody.Seek(0, io.SeekStart) 4595 if len(code) != 0 { 4596 errorCode = restjson.SanitizeErrorCode(code) 4597 } 4598 if len(message) != 0 { 4599 errorMessage = message 4600 } 4601 4602 switch { 4603 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4604 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4605 4606 case strings.EqualFold("InternalServiceErrorException", errorCode): 4607 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4608 4609 case strings.EqualFold("InvalidArgumentException", errorCode): 4610 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4611 4612 default: 4613 genericError := &smithy.GenericAPIError{ 4614 Code: errorCode, 4615 Message: errorMessage, 4616 } 4617 return genericError 4618 4619 } 4620} 4621 4622type awsAwsjson11_deserializeOpUpdateAcceleratorAttributes struct { 4623} 4624 4625func (*awsAwsjson11_deserializeOpUpdateAcceleratorAttributes) ID() string { 4626 return "OperationDeserializer" 4627} 4628 4629func (m *awsAwsjson11_deserializeOpUpdateAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4630 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4631) { 4632 out, metadata, err = next.HandleDeserialize(ctx, in) 4633 if err != nil { 4634 return out, metadata, err 4635 } 4636 4637 response, ok := out.RawResponse.(*smithyhttp.Response) 4638 if !ok { 4639 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4640 } 4641 4642 if response.StatusCode < 200 || response.StatusCode >= 300 { 4643 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateAcceleratorAttributes(response, &metadata) 4644 } 4645 output := &UpdateAcceleratorAttributesOutput{} 4646 out.Result = output 4647 4648 var buff [1024]byte 4649 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4650 4651 body := io.TeeReader(response.Body, ringBuffer) 4652 decoder := json.NewDecoder(body) 4653 decoder.UseNumber() 4654 var shape interface{} 4655 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4656 var snapshot bytes.Buffer 4657 io.Copy(&snapshot, ringBuffer) 4658 err = &smithy.DeserializationError{ 4659 Err: fmt.Errorf("failed to decode response body, %w", err), 4660 Snapshot: snapshot.Bytes(), 4661 } 4662 return out, metadata, err 4663 } 4664 4665 err = awsAwsjson11_deserializeOpDocumentUpdateAcceleratorAttributesOutput(&output, shape) 4666 if err != nil { 4667 var snapshot bytes.Buffer 4668 io.Copy(&snapshot, ringBuffer) 4669 err = &smithy.DeserializationError{ 4670 Err: fmt.Errorf("failed to decode response body, %w", err), 4671 Snapshot: snapshot.Bytes(), 4672 } 4673 return out, metadata, err 4674 } 4675 4676 return out, metadata, err 4677} 4678 4679func awsAwsjson11_deserializeOpErrorUpdateAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4680 var errorBuffer bytes.Buffer 4681 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4682 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4683 } 4684 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4685 4686 errorCode := "UnknownError" 4687 errorMessage := errorCode 4688 4689 code := response.Header.Get("X-Amzn-ErrorType") 4690 if len(code) != 0 { 4691 errorCode = restjson.SanitizeErrorCode(code) 4692 } 4693 4694 var buff [1024]byte 4695 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4696 4697 body := io.TeeReader(errorBody, ringBuffer) 4698 decoder := json.NewDecoder(body) 4699 decoder.UseNumber() 4700 code, message, err := restjson.GetErrorInfo(decoder) 4701 if err != nil { 4702 var snapshot bytes.Buffer 4703 io.Copy(&snapshot, ringBuffer) 4704 err = &smithy.DeserializationError{ 4705 Err: fmt.Errorf("failed to decode response body, %w", err), 4706 Snapshot: snapshot.Bytes(), 4707 } 4708 return err 4709 } 4710 4711 errorBody.Seek(0, io.SeekStart) 4712 if len(code) != 0 { 4713 errorCode = restjson.SanitizeErrorCode(code) 4714 } 4715 if len(message) != 0 { 4716 errorMessage = message 4717 } 4718 4719 switch { 4720 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4721 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4722 4723 case strings.EqualFold("AccessDeniedException", errorCode): 4724 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4725 4726 case strings.EqualFold("InternalServiceErrorException", errorCode): 4727 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4728 4729 case strings.EqualFold("InvalidArgumentException", errorCode): 4730 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4731 4732 default: 4733 genericError := &smithy.GenericAPIError{ 4734 Code: errorCode, 4735 Message: errorMessage, 4736 } 4737 return genericError 4738 4739 } 4740} 4741 4742type awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator struct { 4743} 4744 4745func (*awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator) ID() string { 4746 return "OperationDeserializer" 4747} 4748 4749func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingAccelerator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4750 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4751) { 4752 out, metadata, err = next.HandleDeserialize(ctx, in) 4753 if err != nil { 4754 return out, metadata, err 4755 } 4756 4757 response, ok := out.RawResponse.(*smithyhttp.Response) 4758 if !ok { 4759 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4760 } 4761 4762 if response.StatusCode < 200 || response.StatusCode >= 300 { 4763 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAccelerator(response, &metadata) 4764 } 4765 output := &UpdateCustomRoutingAcceleratorOutput{} 4766 out.Result = output 4767 4768 var buff [1024]byte 4769 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4770 4771 body := io.TeeReader(response.Body, ringBuffer) 4772 decoder := json.NewDecoder(body) 4773 decoder.UseNumber() 4774 var shape interface{} 4775 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4776 var snapshot bytes.Buffer 4777 io.Copy(&snapshot, ringBuffer) 4778 err = &smithy.DeserializationError{ 4779 Err: fmt.Errorf("failed to decode response body, %w", err), 4780 Snapshot: snapshot.Bytes(), 4781 } 4782 return out, metadata, err 4783 } 4784 4785 err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorOutput(&output, shape) 4786 if err != nil { 4787 var snapshot bytes.Buffer 4788 io.Copy(&snapshot, ringBuffer) 4789 err = &smithy.DeserializationError{ 4790 Err: fmt.Errorf("failed to decode response body, %w", err), 4791 Snapshot: snapshot.Bytes(), 4792 } 4793 return out, metadata, err 4794 } 4795 4796 return out, metadata, err 4797} 4798 4799func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAccelerator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4800 var errorBuffer bytes.Buffer 4801 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4802 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4803 } 4804 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4805 4806 errorCode := "UnknownError" 4807 errorMessage := errorCode 4808 4809 code := response.Header.Get("X-Amzn-ErrorType") 4810 if len(code) != 0 { 4811 errorCode = restjson.SanitizeErrorCode(code) 4812 } 4813 4814 var buff [1024]byte 4815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4816 4817 body := io.TeeReader(errorBody, ringBuffer) 4818 decoder := json.NewDecoder(body) 4819 decoder.UseNumber() 4820 code, message, err := restjson.GetErrorInfo(decoder) 4821 if err != nil { 4822 var snapshot bytes.Buffer 4823 io.Copy(&snapshot, ringBuffer) 4824 err = &smithy.DeserializationError{ 4825 Err: fmt.Errorf("failed to decode response body, %w", err), 4826 Snapshot: snapshot.Bytes(), 4827 } 4828 return err 4829 } 4830 4831 errorBody.Seek(0, io.SeekStart) 4832 if len(code) != 0 { 4833 errorCode = restjson.SanitizeErrorCode(code) 4834 } 4835 if len(message) != 0 { 4836 errorMessage = message 4837 } 4838 4839 switch { 4840 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4841 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4842 4843 case strings.EqualFold("InternalServiceErrorException", errorCode): 4844 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4845 4846 case strings.EqualFold("InvalidArgumentException", errorCode): 4847 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4848 4849 default: 4850 genericError := &smithy.GenericAPIError{ 4851 Code: errorCode, 4852 Message: errorMessage, 4853 } 4854 return genericError 4855 4856 } 4857} 4858 4859type awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes struct { 4860} 4861 4862func (*awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes) ID() string { 4863 return "OperationDeserializer" 4864} 4865 4866func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingAcceleratorAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4867 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4868) { 4869 out, metadata, err = next.HandleDeserialize(ctx, in) 4870 if err != nil { 4871 return out, metadata, err 4872 } 4873 4874 response, ok := out.RawResponse.(*smithyhttp.Response) 4875 if !ok { 4876 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4877 } 4878 4879 if response.StatusCode < 200 || response.StatusCode >= 300 { 4880 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAcceleratorAttributes(response, &metadata) 4881 } 4882 output := &UpdateCustomRoutingAcceleratorAttributesOutput{} 4883 out.Result = output 4884 4885 var buff [1024]byte 4886 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4887 4888 body := io.TeeReader(response.Body, ringBuffer) 4889 decoder := json.NewDecoder(body) 4890 decoder.UseNumber() 4891 var shape interface{} 4892 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4893 var snapshot bytes.Buffer 4894 io.Copy(&snapshot, ringBuffer) 4895 err = &smithy.DeserializationError{ 4896 Err: fmt.Errorf("failed to decode response body, %w", err), 4897 Snapshot: snapshot.Bytes(), 4898 } 4899 return out, metadata, err 4900 } 4901 4902 err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorAttributesOutput(&output, shape) 4903 if err != nil { 4904 var snapshot bytes.Buffer 4905 io.Copy(&snapshot, ringBuffer) 4906 err = &smithy.DeserializationError{ 4907 Err: fmt.Errorf("failed to decode response body, %w", err), 4908 Snapshot: snapshot.Bytes(), 4909 } 4910 return out, metadata, err 4911 } 4912 4913 return out, metadata, err 4914} 4915 4916func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingAcceleratorAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4917 var errorBuffer bytes.Buffer 4918 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4919 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4920 } 4921 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4922 4923 errorCode := "UnknownError" 4924 errorMessage := errorCode 4925 4926 code := response.Header.Get("X-Amzn-ErrorType") 4927 if len(code) != 0 { 4928 errorCode = restjson.SanitizeErrorCode(code) 4929 } 4930 4931 var buff [1024]byte 4932 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4933 4934 body := io.TeeReader(errorBody, ringBuffer) 4935 decoder := json.NewDecoder(body) 4936 decoder.UseNumber() 4937 code, message, err := restjson.GetErrorInfo(decoder) 4938 if err != nil { 4939 var snapshot bytes.Buffer 4940 io.Copy(&snapshot, ringBuffer) 4941 err = &smithy.DeserializationError{ 4942 Err: fmt.Errorf("failed to decode response body, %w", err), 4943 Snapshot: snapshot.Bytes(), 4944 } 4945 return err 4946 } 4947 4948 errorBody.Seek(0, io.SeekStart) 4949 if len(code) != 0 { 4950 errorCode = restjson.SanitizeErrorCode(code) 4951 } 4952 if len(message) != 0 { 4953 errorMessage = message 4954 } 4955 4956 switch { 4957 case strings.EqualFold("AcceleratorNotFoundException", errorCode): 4958 return awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response, errorBody) 4959 4960 case strings.EqualFold("AccessDeniedException", errorCode): 4961 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4962 4963 case strings.EqualFold("InternalServiceErrorException", errorCode): 4964 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 4965 4966 case strings.EqualFold("InvalidArgumentException", errorCode): 4967 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 4968 4969 default: 4970 genericError := &smithy.GenericAPIError{ 4971 Code: errorCode, 4972 Message: errorMessage, 4973 } 4974 return genericError 4975 4976 } 4977} 4978 4979type awsAwsjson11_deserializeOpUpdateCustomRoutingListener struct { 4980} 4981 4982func (*awsAwsjson11_deserializeOpUpdateCustomRoutingListener) ID() string { 4983 return "OperationDeserializer" 4984} 4985 4986func (m *awsAwsjson11_deserializeOpUpdateCustomRoutingListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4988) { 4989 out, metadata, err = next.HandleDeserialize(ctx, in) 4990 if err != nil { 4991 return out, metadata, err 4992 } 4993 4994 response, ok := out.RawResponse.(*smithyhttp.Response) 4995 if !ok { 4996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4997 } 4998 4999 if response.StatusCode < 200 || response.StatusCode >= 300 { 5000 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCustomRoutingListener(response, &metadata) 5001 } 5002 output := &UpdateCustomRoutingListenerOutput{} 5003 out.Result = output 5004 5005 var buff [1024]byte 5006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5007 5008 body := io.TeeReader(response.Body, ringBuffer) 5009 decoder := json.NewDecoder(body) 5010 decoder.UseNumber() 5011 var shape interface{} 5012 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5013 var snapshot bytes.Buffer 5014 io.Copy(&snapshot, ringBuffer) 5015 err = &smithy.DeserializationError{ 5016 Err: fmt.Errorf("failed to decode response body, %w", err), 5017 Snapshot: snapshot.Bytes(), 5018 } 5019 return out, metadata, err 5020 } 5021 5022 err = awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingListenerOutput(&output, shape) 5023 if err != nil { 5024 var snapshot bytes.Buffer 5025 io.Copy(&snapshot, ringBuffer) 5026 err = &smithy.DeserializationError{ 5027 Err: fmt.Errorf("failed to decode response body, %w", err), 5028 Snapshot: snapshot.Bytes(), 5029 } 5030 return out, metadata, err 5031 } 5032 5033 return out, metadata, err 5034} 5035 5036func awsAwsjson11_deserializeOpErrorUpdateCustomRoutingListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5037 var errorBuffer bytes.Buffer 5038 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5039 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5040 } 5041 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5042 5043 errorCode := "UnknownError" 5044 errorMessage := errorCode 5045 5046 code := response.Header.Get("X-Amzn-ErrorType") 5047 if len(code) != 0 { 5048 errorCode = restjson.SanitizeErrorCode(code) 5049 } 5050 5051 var buff [1024]byte 5052 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5053 5054 body := io.TeeReader(errorBody, ringBuffer) 5055 decoder := json.NewDecoder(body) 5056 decoder.UseNumber() 5057 code, message, err := restjson.GetErrorInfo(decoder) 5058 if err != nil { 5059 var snapshot bytes.Buffer 5060 io.Copy(&snapshot, ringBuffer) 5061 err = &smithy.DeserializationError{ 5062 Err: fmt.Errorf("failed to decode response body, %w", err), 5063 Snapshot: snapshot.Bytes(), 5064 } 5065 return err 5066 } 5067 5068 errorBody.Seek(0, io.SeekStart) 5069 if len(code) != 0 { 5070 errorCode = restjson.SanitizeErrorCode(code) 5071 } 5072 if len(message) != 0 { 5073 errorMessage = message 5074 } 5075 5076 switch { 5077 case strings.EqualFold("InternalServiceErrorException", errorCode): 5078 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5079 5080 case strings.EqualFold("InvalidArgumentException", errorCode): 5081 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 5082 5083 case strings.EqualFold("InvalidPortRangeException", errorCode): 5084 return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody) 5085 5086 case strings.EqualFold("LimitExceededException", errorCode): 5087 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5088 5089 case strings.EqualFold("ListenerNotFoundException", errorCode): 5090 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 5091 5092 default: 5093 genericError := &smithy.GenericAPIError{ 5094 Code: errorCode, 5095 Message: errorMessage, 5096 } 5097 return genericError 5098 5099 } 5100} 5101 5102type awsAwsjson11_deserializeOpUpdateEndpointGroup struct { 5103} 5104 5105func (*awsAwsjson11_deserializeOpUpdateEndpointGroup) ID() string { 5106 return "OperationDeserializer" 5107} 5108 5109func (m *awsAwsjson11_deserializeOpUpdateEndpointGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5110 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5111) { 5112 out, metadata, err = next.HandleDeserialize(ctx, in) 5113 if err != nil { 5114 return out, metadata, err 5115 } 5116 5117 response, ok := out.RawResponse.(*smithyhttp.Response) 5118 if !ok { 5119 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5120 } 5121 5122 if response.StatusCode < 200 || response.StatusCode >= 300 { 5123 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateEndpointGroup(response, &metadata) 5124 } 5125 output := &UpdateEndpointGroupOutput{} 5126 out.Result = output 5127 5128 var buff [1024]byte 5129 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5130 5131 body := io.TeeReader(response.Body, ringBuffer) 5132 decoder := json.NewDecoder(body) 5133 decoder.UseNumber() 5134 var shape interface{} 5135 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5136 var snapshot bytes.Buffer 5137 io.Copy(&snapshot, ringBuffer) 5138 err = &smithy.DeserializationError{ 5139 Err: fmt.Errorf("failed to decode response body, %w", err), 5140 Snapshot: snapshot.Bytes(), 5141 } 5142 return out, metadata, err 5143 } 5144 5145 err = awsAwsjson11_deserializeOpDocumentUpdateEndpointGroupOutput(&output, shape) 5146 if err != nil { 5147 var snapshot bytes.Buffer 5148 io.Copy(&snapshot, ringBuffer) 5149 err = &smithy.DeserializationError{ 5150 Err: fmt.Errorf("failed to decode response body, %w", err), 5151 Snapshot: snapshot.Bytes(), 5152 } 5153 return out, metadata, err 5154 } 5155 5156 return out, metadata, err 5157} 5158 5159func awsAwsjson11_deserializeOpErrorUpdateEndpointGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5160 var errorBuffer bytes.Buffer 5161 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5162 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5163 } 5164 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5165 5166 errorCode := "UnknownError" 5167 errorMessage := errorCode 5168 5169 code := response.Header.Get("X-Amzn-ErrorType") 5170 if len(code) != 0 { 5171 errorCode = restjson.SanitizeErrorCode(code) 5172 } 5173 5174 var buff [1024]byte 5175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5176 5177 body := io.TeeReader(errorBody, ringBuffer) 5178 decoder := json.NewDecoder(body) 5179 decoder.UseNumber() 5180 code, message, err := restjson.GetErrorInfo(decoder) 5181 if err != nil { 5182 var snapshot bytes.Buffer 5183 io.Copy(&snapshot, ringBuffer) 5184 err = &smithy.DeserializationError{ 5185 Err: fmt.Errorf("failed to decode response body, %w", err), 5186 Snapshot: snapshot.Bytes(), 5187 } 5188 return err 5189 } 5190 5191 errorBody.Seek(0, io.SeekStart) 5192 if len(code) != 0 { 5193 errorCode = restjson.SanitizeErrorCode(code) 5194 } 5195 if len(message) != 0 { 5196 errorMessage = message 5197 } 5198 5199 switch { 5200 case strings.EqualFold("AccessDeniedException", errorCode): 5201 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5202 5203 case strings.EqualFold("EndpointGroupNotFoundException", errorCode): 5204 return awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response, errorBody) 5205 5206 case strings.EqualFold("InternalServiceErrorException", errorCode): 5207 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5208 5209 case strings.EqualFold("InvalidArgumentException", errorCode): 5210 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 5211 5212 case strings.EqualFold("LimitExceededException", errorCode): 5213 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5214 5215 default: 5216 genericError := &smithy.GenericAPIError{ 5217 Code: errorCode, 5218 Message: errorMessage, 5219 } 5220 return genericError 5221 5222 } 5223} 5224 5225type awsAwsjson11_deserializeOpUpdateListener struct { 5226} 5227 5228func (*awsAwsjson11_deserializeOpUpdateListener) ID() string { 5229 return "OperationDeserializer" 5230} 5231 5232func (m *awsAwsjson11_deserializeOpUpdateListener) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5233 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5234) { 5235 out, metadata, err = next.HandleDeserialize(ctx, in) 5236 if err != nil { 5237 return out, metadata, err 5238 } 5239 5240 response, ok := out.RawResponse.(*smithyhttp.Response) 5241 if !ok { 5242 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5243 } 5244 5245 if response.StatusCode < 200 || response.StatusCode >= 300 { 5246 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateListener(response, &metadata) 5247 } 5248 output := &UpdateListenerOutput{} 5249 out.Result = output 5250 5251 var buff [1024]byte 5252 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5253 5254 body := io.TeeReader(response.Body, ringBuffer) 5255 decoder := json.NewDecoder(body) 5256 decoder.UseNumber() 5257 var shape interface{} 5258 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5259 var snapshot bytes.Buffer 5260 io.Copy(&snapshot, ringBuffer) 5261 err = &smithy.DeserializationError{ 5262 Err: fmt.Errorf("failed to decode response body, %w", err), 5263 Snapshot: snapshot.Bytes(), 5264 } 5265 return out, metadata, err 5266 } 5267 5268 err = awsAwsjson11_deserializeOpDocumentUpdateListenerOutput(&output, shape) 5269 if err != nil { 5270 var snapshot bytes.Buffer 5271 io.Copy(&snapshot, ringBuffer) 5272 err = &smithy.DeserializationError{ 5273 Err: fmt.Errorf("failed to decode response body, %w", err), 5274 Snapshot: snapshot.Bytes(), 5275 } 5276 return out, metadata, err 5277 } 5278 5279 return out, metadata, err 5280} 5281 5282func awsAwsjson11_deserializeOpErrorUpdateListener(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5283 var errorBuffer bytes.Buffer 5284 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5285 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5286 } 5287 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5288 5289 errorCode := "UnknownError" 5290 errorMessage := errorCode 5291 5292 code := response.Header.Get("X-Amzn-ErrorType") 5293 if len(code) != 0 { 5294 errorCode = restjson.SanitizeErrorCode(code) 5295 } 5296 5297 var buff [1024]byte 5298 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5299 5300 body := io.TeeReader(errorBody, ringBuffer) 5301 decoder := json.NewDecoder(body) 5302 decoder.UseNumber() 5303 code, message, err := restjson.GetErrorInfo(decoder) 5304 if err != nil { 5305 var snapshot bytes.Buffer 5306 io.Copy(&snapshot, ringBuffer) 5307 err = &smithy.DeserializationError{ 5308 Err: fmt.Errorf("failed to decode response body, %w", err), 5309 Snapshot: snapshot.Bytes(), 5310 } 5311 return err 5312 } 5313 5314 errorBody.Seek(0, io.SeekStart) 5315 if len(code) != 0 { 5316 errorCode = restjson.SanitizeErrorCode(code) 5317 } 5318 if len(message) != 0 { 5319 errorMessage = message 5320 } 5321 5322 switch { 5323 case strings.EqualFold("InternalServiceErrorException", errorCode): 5324 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5325 5326 case strings.EqualFold("InvalidArgumentException", errorCode): 5327 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 5328 5329 case strings.EqualFold("InvalidPortRangeException", errorCode): 5330 return awsAwsjson11_deserializeErrorInvalidPortRangeException(response, errorBody) 5331 5332 case strings.EqualFold("LimitExceededException", errorCode): 5333 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5334 5335 case strings.EqualFold("ListenerNotFoundException", errorCode): 5336 return awsAwsjson11_deserializeErrorListenerNotFoundException(response, errorBody) 5337 5338 default: 5339 genericError := &smithy.GenericAPIError{ 5340 Code: errorCode, 5341 Message: errorMessage, 5342 } 5343 return genericError 5344 5345 } 5346} 5347 5348type awsAwsjson11_deserializeOpWithdrawByoipCidr struct { 5349} 5350 5351func (*awsAwsjson11_deserializeOpWithdrawByoipCidr) ID() string { 5352 return "OperationDeserializer" 5353} 5354 5355func (m *awsAwsjson11_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5356 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5357) { 5358 out, metadata, err = next.HandleDeserialize(ctx, in) 5359 if err != nil { 5360 return out, metadata, err 5361 } 5362 5363 response, ok := out.RawResponse.(*smithyhttp.Response) 5364 if !ok { 5365 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5366 } 5367 5368 if response.StatusCode < 200 || response.StatusCode >= 300 { 5369 return out, metadata, awsAwsjson11_deserializeOpErrorWithdrawByoipCidr(response, &metadata) 5370 } 5371 output := &WithdrawByoipCidrOutput{} 5372 out.Result = output 5373 5374 var buff [1024]byte 5375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5376 5377 body := io.TeeReader(response.Body, ringBuffer) 5378 decoder := json.NewDecoder(body) 5379 decoder.UseNumber() 5380 var shape interface{} 5381 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5382 var snapshot bytes.Buffer 5383 io.Copy(&snapshot, ringBuffer) 5384 err = &smithy.DeserializationError{ 5385 Err: fmt.Errorf("failed to decode response body, %w", err), 5386 Snapshot: snapshot.Bytes(), 5387 } 5388 return out, metadata, err 5389 } 5390 5391 err = awsAwsjson11_deserializeOpDocumentWithdrawByoipCidrOutput(&output, shape) 5392 if err != nil { 5393 var snapshot bytes.Buffer 5394 io.Copy(&snapshot, ringBuffer) 5395 err = &smithy.DeserializationError{ 5396 Err: fmt.Errorf("failed to decode response body, %w", err), 5397 Snapshot: snapshot.Bytes(), 5398 } 5399 return out, metadata, err 5400 } 5401 5402 return out, metadata, err 5403} 5404 5405func awsAwsjson11_deserializeOpErrorWithdrawByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5406 var errorBuffer bytes.Buffer 5407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5409 } 5410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5411 5412 errorCode := "UnknownError" 5413 errorMessage := errorCode 5414 5415 code := response.Header.Get("X-Amzn-ErrorType") 5416 if len(code) != 0 { 5417 errorCode = restjson.SanitizeErrorCode(code) 5418 } 5419 5420 var buff [1024]byte 5421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5422 5423 body := io.TeeReader(errorBody, ringBuffer) 5424 decoder := json.NewDecoder(body) 5425 decoder.UseNumber() 5426 code, message, err := restjson.GetErrorInfo(decoder) 5427 if err != nil { 5428 var snapshot bytes.Buffer 5429 io.Copy(&snapshot, ringBuffer) 5430 err = &smithy.DeserializationError{ 5431 Err: fmt.Errorf("failed to decode response body, %w", err), 5432 Snapshot: snapshot.Bytes(), 5433 } 5434 return err 5435 } 5436 5437 errorBody.Seek(0, io.SeekStart) 5438 if len(code) != 0 { 5439 errorCode = restjson.SanitizeErrorCode(code) 5440 } 5441 if len(message) != 0 { 5442 errorMessage = message 5443 } 5444 5445 switch { 5446 case strings.EqualFold("AccessDeniedException", errorCode): 5447 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5448 5449 case strings.EqualFold("ByoipCidrNotFoundException", errorCode): 5450 return awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response, errorBody) 5451 5452 case strings.EqualFold("IncorrectCidrStateException", errorCode): 5453 return awsAwsjson11_deserializeErrorIncorrectCidrStateException(response, errorBody) 5454 5455 case strings.EqualFold("InternalServiceErrorException", errorCode): 5456 return awsAwsjson11_deserializeErrorInternalServiceErrorException(response, errorBody) 5457 5458 case strings.EqualFold("InvalidArgumentException", errorCode): 5459 return awsAwsjson11_deserializeErrorInvalidArgumentException(response, errorBody) 5460 5461 default: 5462 genericError := &smithy.GenericAPIError{ 5463 Code: errorCode, 5464 Message: errorMessage, 5465 } 5466 return genericError 5467 5468 } 5469} 5470 5471func awsAwsjson11_deserializeErrorAcceleratorNotDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5472 var buff [1024]byte 5473 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5474 5475 body := io.TeeReader(errorBody, ringBuffer) 5476 decoder := json.NewDecoder(body) 5477 decoder.UseNumber() 5478 var shape interface{} 5479 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5480 var snapshot bytes.Buffer 5481 io.Copy(&snapshot, ringBuffer) 5482 err = &smithy.DeserializationError{ 5483 Err: fmt.Errorf("failed to decode response body, %w", err), 5484 Snapshot: snapshot.Bytes(), 5485 } 5486 return err 5487 } 5488 5489 output := &types.AcceleratorNotDisabledException{} 5490 err := awsAwsjson11_deserializeDocumentAcceleratorNotDisabledException(&output, shape) 5491 5492 if err != nil { 5493 var snapshot bytes.Buffer 5494 io.Copy(&snapshot, ringBuffer) 5495 err = &smithy.DeserializationError{ 5496 Err: fmt.Errorf("failed to decode response body, %w", err), 5497 Snapshot: snapshot.Bytes(), 5498 } 5499 return err 5500 } 5501 5502 errorBody.Seek(0, io.SeekStart) 5503 return output 5504} 5505 5506func awsAwsjson11_deserializeErrorAcceleratorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5507 var buff [1024]byte 5508 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5509 5510 body := io.TeeReader(errorBody, ringBuffer) 5511 decoder := json.NewDecoder(body) 5512 decoder.UseNumber() 5513 var shape interface{} 5514 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5515 var snapshot bytes.Buffer 5516 io.Copy(&snapshot, ringBuffer) 5517 err = &smithy.DeserializationError{ 5518 Err: fmt.Errorf("failed to decode response body, %w", err), 5519 Snapshot: snapshot.Bytes(), 5520 } 5521 return err 5522 } 5523 5524 output := &types.AcceleratorNotFoundException{} 5525 err := awsAwsjson11_deserializeDocumentAcceleratorNotFoundException(&output, shape) 5526 5527 if err != nil { 5528 var snapshot bytes.Buffer 5529 io.Copy(&snapshot, ringBuffer) 5530 err = &smithy.DeserializationError{ 5531 Err: fmt.Errorf("failed to decode response body, %w", err), 5532 Snapshot: snapshot.Bytes(), 5533 } 5534 return err 5535 } 5536 5537 errorBody.Seek(0, io.SeekStart) 5538 return output 5539} 5540 5541func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5542 var buff [1024]byte 5543 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5544 5545 body := io.TeeReader(errorBody, ringBuffer) 5546 decoder := json.NewDecoder(body) 5547 decoder.UseNumber() 5548 var shape interface{} 5549 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5550 var snapshot bytes.Buffer 5551 io.Copy(&snapshot, ringBuffer) 5552 err = &smithy.DeserializationError{ 5553 Err: fmt.Errorf("failed to decode response body, %w", err), 5554 Snapshot: snapshot.Bytes(), 5555 } 5556 return err 5557 } 5558 5559 output := &types.AccessDeniedException{} 5560 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 5561 5562 if err != nil { 5563 var snapshot bytes.Buffer 5564 io.Copy(&snapshot, ringBuffer) 5565 err = &smithy.DeserializationError{ 5566 Err: fmt.Errorf("failed to decode response body, %w", err), 5567 Snapshot: snapshot.Bytes(), 5568 } 5569 return err 5570 } 5571 5572 errorBody.Seek(0, io.SeekStart) 5573 return output 5574} 5575 5576func awsAwsjson11_deserializeErrorAssociatedEndpointGroupFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5577 var buff [1024]byte 5578 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5579 5580 body := io.TeeReader(errorBody, ringBuffer) 5581 decoder := json.NewDecoder(body) 5582 decoder.UseNumber() 5583 var shape interface{} 5584 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5585 var snapshot bytes.Buffer 5586 io.Copy(&snapshot, ringBuffer) 5587 err = &smithy.DeserializationError{ 5588 Err: fmt.Errorf("failed to decode response body, %w", err), 5589 Snapshot: snapshot.Bytes(), 5590 } 5591 return err 5592 } 5593 5594 output := &types.AssociatedEndpointGroupFoundException{} 5595 err := awsAwsjson11_deserializeDocumentAssociatedEndpointGroupFoundException(&output, shape) 5596 5597 if err != nil { 5598 var snapshot bytes.Buffer 5599 io.Copy(&snapshot, ringBuffer) 5600 err = &smithy.DeserializationError{ 5601 Err: fmt.Errorf("failed to decode response body, %w", err), 5602 Snapshot: snapshot.Bytes(), 5603 } 5604 return err 5605 } 5606 5607 errorBody.Seek(0, io.SeekStart) 5608 return output 5609} 5610 5611func awsAwsjson11_deserializeErrorAssociatedListenerFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5612 var buff [1024]byte 5613 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5614 5615 body := io.TeeReader(errorBody, ringBuffer) 5616 decoder := json.NewDecoder(body) 5617 decoder.UseNumber() 5618 var shape interface{} 5619 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5620 var snapshot bytes.Buffer 5621 io.Copy(&snapshot, ringBuffer) 5622 err = &smithy.DeserializationError{ 5623 Err: fmt.Errorf("failed to decode response body, %w", err), 5624 Snapshot: snapshot.Bytes(), 5625 } 5626 return err 5627 } 5628 5629 output := &types.AssociatedListenerFoundException{} 5630 err := awsAwsjson11_deserializeDocumentAssociatedListenerFoundException(&output, shape) 5631 5632 if err != nil { 5633 var snapshot bytes.Buffer 5634 io.Copy(&snapshot, ringBuffer) 5635 err = &smithy.DeserializationError{ 5636 Err: fmt.Errorf("failed to decode response body, %w", err), 5637 Snapshot: snapshot.Bytes(), 5638 } 5639 return err 5640 } 5641 5642 errorBody.Seek(0, io.SeekStart) 5643 return output 5644} 5645 5646func awsAwsjson11_deserializeErrorByoipCidrNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5647 var buff [1024]byte 5648 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5649 5650 body := io.TeeReader(errorBody, ringBuffer) 5651 decoder := json.NewDecoder(body) 5652 decoder.UseNumber() 5653 var shape interface{} 5654 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5655 var snapshot bytes.Buffer 5656 io.Copy(&snapshot, ringBuffer) 5657 err = &smithy.DeserializationError{ 5658 Err: fmt.Errorf("failed to decode response body, %w", err), 5659 Snapshot: snapshot.Bytes(), 5660 } 5661 return err 5662 } 5663 5664 output := &types.ByoipCidrNotFoundException{} 5665 err := awsAwsjson11_deserializeDocumentByoipCidrNotFoundException(&output, shape) 5666 5667 if err != nil { 5668 var snapshot bytes.Buffer 5669 io.Copy(&snapshot, ringBuffer) 5670 err = &smithy.DeserializationError{ 5671 Err: fmt.Errorf("failed to decode response body, %w", err), 5672 Snapshot: snapshot.Bytes(), 5673 } 5674 return err 5675 } 5676 5677 errorBody.Seek(0, io.SeekStart) 5678 return output 5679} 5680 5681func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5682 var buff [1024]byte 5683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5684 5685 body := io.TeeReader(errorBody, ringBuffer) 5686 decoder := json.NewDecoder(body) 5687 decoder.UseNumber() 5688 var shape interface{} 5689 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5690 var snapshot bytes.Buffer 5691 io.Copy(&snapshot, ringBuffer) 5692 err = &smithy.DeserializationError{ 5693 Err: fmt.Errorf("failed to decode response body, %w", err), 5694 Snapshot: snapshot.Bytes(), 5695 } 5696 return err 5697 } 5698 5699 output := &types.ConflictException{} 5700 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 5701 5702 if err != nil { 5703 var snapshot bytes.Buffer 5704 io.Copy(&snapshot, ringBuffer) 5705 err = &smithy.DeserializationError{ 5706 Err: fmt.Errorf("failed to decode response body, %w", err), 5707 Snapshot: snapshot.Bytes(), 5708 } 5709 return err 5710 } 5711 5712 errorBody.Seek(0, io.SeekStart) 5713 return output 5714} 5715 5716func awsAwsjson11_deserializeErrorEndpointAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5717 var buff [1024]byte 5718 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5719 5720 body := io.TeeReader(errorBody, ringBuffer) 5721 decoder := json.NewDecoder(body) 5722 decoder.UseNumber() 5723 var shape interface{} 5724 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5725 var snapshot bytes.Buffer 5726 io.Copy(&snapshot, ringBuffer) 5727 err = &smithy.DeserializationError{ 5728 Err: fmt.Errorf("failed to decode response body, %w", err), 5729 Snapshot: snapshot.Bytes(), 5730 } 5731 return err 5732 } 5733 5734 output := &types.EndpointAlreadyExistsException{} 5735 err := awsAwsjson11_deserializeDocumentEndpointAlreadyExistsException(&output, shape) 5736 5737 if err != nil { 5738 var snapshot bytes.Buffer 5739 io.Copy(&snapshot, ringBuffer) 5740 err = &smithy.DeserializationError{ 5741 Err: fmt.Errorf("failed to decode response body, %w", err), 5742 Snapshot: snapshot.Bytes(), 5743 } 5744 return err 5745 } 5746 5747 errorBody.Seek(0, io.SeekStart) 5748 return output 5749} 5750 5751func awsAwsjson11_deserializeErrorEndpointGroupAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5752 var buff [1024]byte 5753 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5754 5755 body := io.TeeReader(errorBody, ringBuffer) 5756 decoder := json.NewDecoder(body) 5757 decoder.UseNumber() 5758 var shape interface{} 5759 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5760 var snapshot bytes.Buffer 5761 io.Copy(&snapshot, ringBuffer) 5762 err = &smithy.DeserializationError{ 5763 Err: fmt.Errorf("failed to decode response body, %w", err), 5764 Snapshot: snapshot.Bytes(), 5765 } 5766 return err 5767 } 5768 5769 output := &types.EndpointGroupAlreadyExistsException{} 5770 err := awsAwsjson11_deserializeDocumentEndpointGroupAlreadyExistsException(&output, shape) 5771 5772 if err != nil { 5773 var snapshot bytes.Buffer 5774 io.Copy(&snapshot, ringBuffer) 5775 err = &smithy.DeserializationError{ 5776 Err: fmt.Errorf("failed to decode response body, %w", err), 5777 Snapshot: snapshot.Bytes(), 5778 } 5779 return err 5780 } 5781 5782 errorBody.Seek(0, io.SeekStart) 5783 return output 5784} 5785 5786func awsAwsjson11_deserializeErrorEndpointGroupNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5787 var buff [1024]byte 5788 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5789 5790 body := io.TeeReader(errorBody, ringBuffer) 5791 decoder := json.NewDecoder(body) 5792 decoder.UseNumber() 5793 var shape interface{} 5794 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5795 var snapshot bytes.Buffer 5796 io.Copy(&snapshot, ringBuffer) 5797 err = &smithy.DeserializationError{ 5798 Err: fmt.Errorf("failed to decode response body, %w", err), 5799 Snapshot: snapshot.Bytes(), 5800 } 5801 return err 5802 } 5803 5804 output := &types.EndpointGroupNotFoundException{} 5805 err := awsAwsjson11_deserializeDocumentEndpointGroupNotFoundException(&output, shape) 5806 5807 if err != nil { 5808 var snapshot bytes.Buffer 5809 io.Copy(&snapshot, ringBuffer) 5810 err = &smithy.DeserializationError{ 5811 Err: fmt.Errorf("failed to decode response body, %w", err), 5812 Snapshot: snapshot.Bytes(), 5813 } 5814 return err 5815 } 5816 5817 errorBody.Seek(0, io.SeekStart) 5818 return output 5819} 5820 5821func awsAwsjson11_deserializeErrorEndpointNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5822 var buff [1024]byte 5823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5824 5825 body := io.TeeReader(errorBody, ringBuffer) 5826 decoder := json.NewDecoder(body) 5827 decoder.UseNumber() 5828 var shape interface{} 5829 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5830 var snapshot bytes.Buffer 5831 io.Copy(&snapshot, ringBuffer) 5832 err = &smithy.DeserializationError{ 5833 Err: fmt.Errorf("failed to decode response body, %w", err), 5834 Snapshot: snapshot.Bytes(), 5835 } 5836 return err 5837 } 5838 5839 output := &types.EndpointNotFoundException{} 5840 err := awsAwsjson11_deserializeDocumentEndpointNotFoundException(&output, shape) 5841 5842 if err != nil { 5843 var snapshot bytes.Buffer 5844 io.Copy(&snapshot, ringBuffer) 5845 err = &smithy.DeserializationError{ 5846 Err: fmt.Errorf("failed to decode response body, %w", err), 5847 Snapshot: snapshot.Bytes(), 5848 } 5849 return err 5850 } 5851 5852 errorBody.Seek(0, io.SeekStart) 5853 return output 5854} 5855 5856func awsAwsjson11_deserializeErrorIncorrectCidrStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5857 var buff [1024]byte 5858 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5859 5860 body := io.TeeReader(errorBody, ringBuffer) 5861 decoder := json.NewDecoder(body) 5862 decoder.UseNumber() 5863 var shape interface{} 5864 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5865 var snapshot bytes.Buffer 5866 io.Copy(&snapshot, ringBuffer) 5867 err = &smithy.DeserializationError{ 5868 Err: fmt.Errorf("failed to decode response body, %w", err), 5869 Snapshot: snapshot.Bytes(), 5870 } 5871 return err 5872 } 5873 5874 output := &types.IncorrectCidrStateException{} 5875 err := awsAwsjson11_deserializeDocumentIncorrectCidrStateException(&output, shape) 5876 5877 if err != nil { 5878 var snapshot bytes.Buffer 5879 io.Copy(&snapshot, ringBuffer) 5880 err = &smithy.DeserializationError{ 5881 Err: fmt.Errorf("failed to decode response body, %w", err), 5882 Snapshot: snapshot.Bytes(), 5883 } 5884 return err 5885 } 5886 5887 errorBody.Seek(0, io.SeekStart) 5888 return output 5889} 5890 5891func awsAwsjson11_deserializeErrorInternalServiceErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5892 var buff [1024]byte 5893 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5894 5895 body := io.TeeReader(errorBody, ringBuffer) 5896 decoder := json.NewDecoder(body) 5897 decoder.UseNumber() 5898 var shape interface{} 5899 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5900 var snapshot bytes.Buffer 5901 io.Copy(&snapshot, ringBuffer) 5902 err = &smithy.DeserializationError{ 5903 Err: fmt.Errorf("failed to decode response body, %w", err), 5904 Snapshot: snapshot.Bytes(), 5905 } 5906 return err 5907 } 5908 5909 output := &types.InternalServiceErrorException{} 5910 err := awsAwsjson11_deserializeDocumentInternalServiceErrorException(&output, shape) 5911 5912 if err != nil { 5913 var snapshot bytes.Buffer 5914 io.Copy(&snapshot, ringBuffer) 5915 err = &smithy.DeserializationError{ 5916 Err: fmt.Errorf("failed to decode response body, %w", err), 5917 Snapshot: snapshot.Bytes(), 5918 } 5919 return err 5920 } 5921 5922 errorBody.Seek(0, io.SeekStart) 5923 return output 5924} 5925 5926func awsAwsjson11_deserializeErrorInvalidArgumentException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5927 var buff [1024]byte 5928 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5929 5930 body := io.TeeReader(errorBody, ringBuffer) 5931 decoder := json.NewDecoder(body) 5932 decoder.UseNumber() 5933 var shape interface{} 5934 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5935 var snapshot bytes.Buffer 5936 io.Copy(&snapshot, ringBuffer) 5937 err = &smithy.DeserializationError{ 5938 Err: fmt.Errorf("failed to decode response body, %w", err), 5939 Snapshot: snapshot.Bytes(), 5940 } 5941 return err 5942 } 5943 5944 output := &types.InvalidArgumentException{} 5945 err := awsAwsjson11_deserializeDocumentInvalidArgumentException(&output, shape) 5946 5947 if err != nil { 5948 var snapshot bytes.Buffer 5949 io.Copy(&snapshot, ringBuffer) 5950 err = &smithy.DeserializationError{ 5951 Err: fmt.Errorf("failed to decode response body, %w", err), 5952 Snapshot: snapshot.Bytes(), 5953 } 5954 return err 5955 } 5956 5957 errorBody.Seek(0, io.SeekStart) 5958 return output 5959} 5960 5961func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5962 var buff [1024]byte 5963 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5964 5965 body := io.TeeReader(errorBody, ringBuffer) 5966 decoder := json.NewDecoder(body) 5967 decoder.UseNumber() 5968 var shape interface{} 5969 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5970 var snapshot bytes.Buffer 5971 io.Copy(&snapshot, ringBuffer) 5972 err = &smithy.DeserializationError{ 5973 Err: fmt.Errorf("failed to decode response body, %w", err), 5974 Snapshot: snapshot.Bytes(), 5975 } 5976 return err 5977 } 5978 5979 output := &types.InvalidNextTokenException{} 5980 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 5981 5982 if err != nil { 5983 var snapshot bytes.Buffer 5984 io.Copy(&snapshot, ringBuffer) 5985 err = &smithy.DeserializationError{ 5986 Err: fmt.Errorf("failed to decode response body, %w", err), 5987 Snapshot: snapshot.Bytes(), 5988 } 5989 return err 5990 } 5991 5992 errorBody.Seek(0, io.SeekStart) 5993 return output 5994} 5995 5996func awsAwsjson11_deserializeErrorInvalidPortRangeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5997 var buff [1024]byte 5998 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5999 6000 body := io.TeeReader(errorBody, ringBuffer) 6001 decoder := json.NewDecoder(body) 6002 decoder.UseNumber() 6003 var shape interface{} 6004 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6005 var snapshot bytes.Buffer 6006 io.Copy(&snapshot, ringBuffer) 6007 err = &smithy.DeserializationError{ 6008 Err: fmt.Errorf("failed to decode response body, %w", err), 6009 Snapshot: snapshot.Bytes(), 6010 } 6011 return err 6012 } 6013 6014 output := &types.InvalidPortRangeException{} 6015 err := awsAwsjson11_deserializeDocumentInvalidPortRangeException(&output, shape) 6016 6017 if err != nil { 6018 var snapshot bytes.Buffer 6019 io.Copy(&snapshot, ringBuffer) 6020 err = &smithy.DeserializationError{ 6021 Err: fmt.Errorf("failed to decode response body, %w", err), 6022 Snapshot: snapshot.Bytes(), 6023 } 6024 return err 6025 } 6026 6027 errorBody.Seek(0, io.SeekStart) 6028 return output 6029} 6030 6031func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6032 var buff [1024]byte 6033 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6034 6035 body := io.TeeReader(errorBody, ringBuffer) 6036 decoder := json.NewDecoder(body) 6037 decoder.UseNumber() 6038 var shape interface{} 6039 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6040 var snapshot bytes.Buffer 6041 io.Copy(&snapshot, ringBuffer) 6042 err = &smithy.DeserializationError{ 6043 Err: fmt.Errorf("failed to decode response body, %w", err), 6044 Snapshot: snapshot.Bytes(), 6045 } 6046 return err 6047 } 6048 6049 output := &types.LimitExceededException{} 6050 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 6051 6052 if err != nil { 6053 var snapshot bytes.Buffer 6054 io.Copy(&snapshot, ringBuffer) 6055 err = &smithy.DeserializationError{ 6056 Err: fmt.Errorf("failed to decode response body, %w", err), 6057 Snapshot: snapshot.Bytes(), 6058 } 6059 return err 6060 } 6061 6062 errorBody.Seek(0, io.SeekStart) 6063 return output 6064} 6065 6066func awsAwsjson11_deserializeErrorListenerNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6067 var buff [1024]byte 6068 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6069 6070 body := io.TeeReader(errorBody, ringBuffer) 6071 decoder := json.NewDecoder(body) 6072 decoder.UseNumber() 6073 var shape interface{} 6074 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6075 var snapshot bytes.Buffer 6076 io.Copy(&snapshot, ringBuffer) 6077 err = &smithy.DeserializationError{ 6078 Err: fmt.Errorf("failed to decode response body, %w", err), 6079 Snapshot: snapshot.Bytes(), 6080 } 6081 return err 6082 } 6083 6084 output := &types.ListenerNotFoundException{} 6085 err := awsAwsjson11_deserializeDocumentListenerNotFoundException(&output, shape) 6086 6087 if err != nil { 6088 var snapshot bytes.Buffer 6089 io.Copy(&snapshot, ringBuffer) 6090 err = &smithy.DeserializationError{ 6091 Err: fmt.Errorf("failed to decode response body, %w", err), 6092 Snapshot: snapshot.Bytes(), 6093 } 6094 return err 6095 } 6096 6097 errorBody.Seek(0, io.SeekStart) 6098 return output 6099} 6100 6101func awsAwsjson11_deserializeDocumentAccelerator(v **types.Accelerator, value interface{}) error { 6102 if v == nil { 6103 return fmt.Errorf("unexpected nil of type %T", v) 6104 } 6105 if value == nil { 6106 return nil 6107 } 6108 6109 shape, ok := value.(map[string]interface{}) 6110 if !ok { 6111 return fmt.Errorf("unexpected JSON type %v", value) 6112 } 6113 6114 var sv *types.Accelerator 6115 if *v == nil { 6116 sv = &types.Accelerator{} 6117 } else { 6118 sv = *v 6119 } 6120 6121 for key, value := range shape { 6122 switch key { 6123 case "AcceleratorArn": 6124 if value != nil { 6125 jtv, ok := value.(string) 6126 if !ok { 6127 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6128 } 6129 sv.AcceleratorArn = ptr.String(jtv) 6130 } 6131 6132 case "CreatedTime": 6133 if value != nil { 6134 jtv, ok := value.(json.Number) 6135 if !ok { 6136 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6137 } 6138 f64, err := jtv.Float64() 6139 if err != nil { 6140 return err 6141 } 6142 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6143 } 6144 6145 case "DnsName": 6146 if value != nil { 6147 jtv, ok := value.(string) 6148 if !ok { 6149 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6150 } 6151 sv.DnsName = ptr.String(jtv) 6152 } 6153 6154 case "Enabled": 6155 if value != nil { 6156 jtv, ok := value.(bool) 6157 if !ok { 6158 return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value) 6159 } 6160 sv.Enabled = ptr.Bool(jtv) 6161 } 6162 6163 case "IpAddressType": 6164 if value != nil { 6165 jtv, ok := value.(string) 6166 if !ok { 6167 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value) 6168 } 6169 sv.IpAddressType = types.IpAddressType(jtv) 6170 } 6171 6172 case "IpSets": 6173 if err := awsAwsjson11_deserializeDocumentIpSets(&sv.IpSets, value); err != nil { 6174 return err 6175 } 6176 6177 case "LastModifiedTime": 6178 if value != nil { 6179 jtv, ok := value.(json.Number) 6180 if !ok { 6181 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6182 } 6183 f64, err := jtv.Float64() 6184 if err != nil { 6185 return err 6186 } 6187 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6188 } 6189 6190 case "Name": 6191 if value != nil { 6192 jtv, ok := value.(string) 6193 if !ok { 6194 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6195 } 6196 sv.Name = ptr.String(jtv) 6197 } 6198 6199 case "Status": 6200 if value != nil { 6201 jtv, ok := value.(string) 6202 if !ok { 6203 return fmt.Errorf("expected AcceleratorStatus to be of type string, got %T instead", value) 6204 } 6205 sv.Status = types.AcceleratorStatus(jtv) 6206 } 6207 6208 default: 6209 _, _ = key, value 6210 6211 } 6212 } 6213 *v = sv 6214 return nil 6215} 6216 6217func awsAwsjson11_deserializeDocumentAcceleratorAttributes(v **types.AcceleratorAttributes, value interface{}) error { 6218 if v == nil { 6219 return fmt.Errorf("unexpected nil of type %T", v) 6220 } 6221 if value == nil { 6222 return nil 6223 } 6224 6225 shape, ok := value.(map[string]interface{}) 6226 if !ok { 6227 return fmt.Errorf("unexpected JSON type %v", value) 6228 } 6229 6230 var sv *types.AcceleratorAttributes 6231 if *v == nil { 6232 sv = &types.AcceleratorAttributes{} 6233 } else { 6234 sv = *v 6235 } 6236 6237 for key, value := range shape { 6238 switch key { 6239 case "FlowLogsEnabled": 6240 if value != nil { 6241 jtv, ok := value.(bool) 6242 if !ok { 6243 return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value) 6244 } 6245 sv.FlowLogsEnabled = ptr.Bool(jtv) 6246 } 6247 6248 case "FlowLogsS3Bucket": 6249 if value != nil { 6250 jtv, ok := value.(string) 6251 if !ok { 6252 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6253 } 6254 sv.FlowLogsS3Bucket = ptr.String(jtv) 6255 } 6256 6257 case "FlowLogsS3Prefix": 6258 if value != nil { 6259 jtv, ok := value.(string) 6260 if !ok { 6261 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6262 } 6263 sv.FlowLogsS3Prefix = ptr.String(jtv) 6264 } 6265 6266 default: 6267 _, _ = key, value 6268 6269 } 6270 } 6271 *v = sv 6272 return nil 6273} 6274 6275func awsAwsjson11_deserializeDocumentAcceleratorNotDisabledException(v **types.AcceleratorNotDisabledException, value interface{}) error { 6276 if v == nil { 6277 return fmt.Errorf("unexpected nil of type %T", v) 6278 } 6279 if value == nil { 6280 return nil 6281 } 6282 6283 shape, ok := value.(map[string]interface{}) 6284 if !ok { 6285 return fmt.Errorf("unexpected JSON type %v", value) 6286 } 6287 6288 var sv *types.AcceleratorNotDisabledException 6289 if *v == nil { 6290 sv = &types.AcceleratorNotDisabledException{} 6291 } else { 6292 sv = *v 6293 } 6294 6295 for key, value := range shape { 6296 switch key { 6297 case "Message": 6298 if value != nil { 6299 jtv, ok := value.(string) 6300 if !ok { 6301 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6302 } 6303 sv.Message = ptr.String(jtv) 6304 } 6305 6306 default: 6307 _, _ = key, value 6308 6309 } 6310 } 6311 *v = sv 6312 return nil 6313} 6314 6315func awsAwsjson11_deserializeDocumentAcceleratorNotFoundException(v **types.AcceleratorNotFoundException, value interface{}) error { 6316 if v == nil { 6317 return fmt.Errorf("unexpected nil of type %T", v) 6318 } 6319 if value == nil { 6320 return nil 6321 } 6322 6323 shape, ok := value.(map[string]interface{}) 6324 if !ok { 6325 return fmt.Errorf("unexpected JSON type %v", value) 6326 } 6327 6328 var sv *types.AcceleratorNotFoundException 6329 if *v == nil { 6330 sv = &types.AcceleratorNotFoundException{} 6331 } else { 6332 sv = *v 6333 } 6334 6335 for key, value := range shape { 6336 switch key { 6337 case "Message": 6338 if value != nil { 6339 jtv, ok := value.(string) 6340 if !ok { 6341 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6342 } 6343 sv.Message = ptr.String(jtv) 6344 } 6345 6346 default: 6347 _, _ = key, value 6348 6349 } 6350 } 6351 *v = sv 6352 return nil 6353} 6354 6355func awsAwsjson11_deserializeDocumentAccelerators(v *[]types.Accelerator, value interface{}) error { 6356 if v == nil { 6357 return fmt.Errorf("unexpected nil of type %T", v) 6358 } 6359 if value == nil { 6360 return nil 6361 } 6362 6363 shape, ok := value.([]interface{}) 6364 if !ok { 6365 return fmt.Errorf("unexpected JSON type %v", value) 6366 } 6367 6368 var cv []types.Accelerator 6369 if *v == nil { 6370 cv = []types.Accelerator{} 6371 } else { 6372 cv = *v 6373 } 6374 6375 for _, value := range shape { 6376 var col types.Accelerator 6377 destAddr := &col 6378 if err := awsAwsjson11_deserializeDocumentAccelerator(&destAddr, value); err != nil { 6379 return err 6380 } 6381 col = *destAddr 6382 cv = append(cv, col) 6383 6384 } 6385 *v = cv 6386 return nil 6387} 6388 6389func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 6390 if v == nil { 6391 return fmt.Errorf("unexpected nil of type %T", v) 6392 } 6393 if value == nil { 6394 return nil 6395 } 6396 6397 shape, ok := value.(map[string]interface{}) 6398 if !ok { 6399 return fmt.Errorf("unexpected JSON type %v", value) 6400 } 6401 6402 var sv *types.AccessDeniedException 6403 if *v == nil { 6404 sv = &types.AccessDeniedException{} 6405 } else { 6406 sv = *v 6407 } 6408 6409 for key, value := range shape { 6410 switch key { 6411 case "Message": 6412 if value != nil { 6413 jtv, ok := value.(string) 6414 if !ok { 6415 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6416 } 6417 sv.Message = ptr.String(jtv) 6418 } 6419 6420 default: 6421 _, _ = key, value 6422 6423 } 6424 } 6425 *v = sv 6426 return nil 6427} 6428 6429func awsAwsjson11_deserializeDocumentAssociatedEndpointGroupFoundException(v **types.AssociatedEndpointGroupFoundException, value interface{}) error { 6430 if v == nil { 6431 return fmt.Errorf("unexpected nil of type %T", v) 6432 } 6433 if value == nil { 6434 return nil 6435 } 6436 6437 shape, ok := value.(map[string]interface{}) 6438 if !ok { 6439 return fmt.Errorf("unexpected JSON type %v", value) 6440 } 6441 6442 var sv *types.AssociatedEndpointGroupFoundException 6443 if *v == nil { 6444 sv = &types.AssociatedEndpointGroupFoundException{} 6445 } else { 6446 sv = *v 6447 } 6448 6449 for key, value := range shape { 6450 switch key { 6451 case "Message": 6452 if value != nil { 6453 jtv, ok := value.(string) 6454 if !ok { 6455 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6456 } 6457 sv.Message = ptr.String(jtv) 6458 } 6459 6460 default: 6461 _, _ = key, value 6462 6463 } 6464 } 6465 *v = sv 6466 return nil 6467} 6468 6469func awsAwsjson11_deserializeDocumentAssociatedListenerFoundException(v **types.AssociatedListenerFoundException, value interface{}) error { 6470 if v == nil { 6471 return fmt.Errorf("unexpected nil of type %T", v) 6472 } 6473 if value == nil { 6474 return nil 6475 } 6476 6477 shape, ok := value.(map[string]interface{}) 6478 if !ok { 6479 return fmt.Errorf("unexpected JSON type %v", value) 6480 } 6481 6482 var sv *types.AssociatedListenerFoundException 6483 if *v == nil { 6484 sv = &types.AssociatedListenerFoundException{} 6485 } else { 6486 sv = *v 6487 } 6488 6489 for key, value := range shape { 6490 switch key { 6491 case "Message": 6492 if value != nil { 6493 jtv, ok := value.(string) 6494 if !ok { 6495 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6496 } 6497 sv.Message = ptr.String(jtv) 6498 } 6499 6500 default: 6501 _, _ = key, value 6502 6503 } 6504 } 6505 *v = sv 6506 return nil 6507} 6508 6509func awsAwsjson11_deserializeDocumentByoipCidr(v **types.ByoipCidr, value interface{}) error { 6510 if v == nil { 6511 return fmt.Errorf("unexpected nil of type %T", v) 6512 } 6513 if value == nil { 6514 return nil 6515 } 6516 6517 shape, ok := value.(map[string]interface{}) 6518 if !ok { 6519 return fmt.Errorf("unexpected JSON type %v", value) 6520 } 6521 6522 var sv *types.ByoipCidr 6523 if *v == nil { 6524 sv = &types.ByoipCidr{} 6525 } else { 6526 sv = *v 6527 } 6528 6529 for key, value := range shape { 6530 switch key { 6531 case "Cidr": 6532 if value != nil { 6533 jtv, ok := value.(string) 6534 if !ok { 6535 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6536 } 6537 sv.Cidr = ptr.String(jtv) 6538 } 6539 6540 case "Events": 6541 if err := awsAwsjson11_deserializeDocumentByoipCidrEvents(&sv.Events, value); err != nil { 6542 return err 6543 } 6544 6545 case "State": 6546 if value != nil { 6547 jtv, ok := value.(string) 6548 if !ok { 6549 return fmt.Errorf("expected ByoipCidrState to be of type string, got %T instead", value) 6550 } 6551 sv.State = types.ByoipCidrState(jtv) 6552 } 6553 6554 default: 6555 _, _ = key, value 6556 6557 } 6558 } 6559 *v = sv 6560 return nil 6561} 6562 6563func awsAwsjson11_deserializeDocumentByoipCidrEvent(v **types.ByoipCidrEvent, value interface{}) error { 6564 if v == nil { 6565 return fmt.Errorf("unexpected nil of type %T", v) 6566 } 6567 if value == nil { 6568 return nil 6569 } 6570 6571 shape, ok := value.(map[string]interface{}) 6572 if !ok { 6573 return fmt.Errorf("unexpected JSON type %v", value) 6574 } 6575 6576 var sv *types.ByoipCidrEvent 6577 if *v == nil { 6578 sv = &types.ByoipCidrEvent{} 6579 } else { 6580 sv = *v 6581 } 6582 6583 for key, value := range shape { 6584 switch key { 6585 case "Message": 6586 if value != nil { 6587 jtv, ok := value.(string) 6588 if !ok { 6589 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6590 } 6591 sv.Message = ptr.String(jtv) 6592 } 6593 6594 case "Timestamp": 6595 if value != nil { 6596 jtv, ok := value.(json.Number) 6597 if !ok { 6598 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6599 } 6600 f64, err := jtv.Float64() 6601 if err != nil { 6602 return err 6603 } 6604 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6605 } 6606 6607 default: 6608 _, _ = key, value 6609 6610 } 6611 } 6612 *v = sv 6613 return nil 6614} 6615 6616func awsAwsjson11_deserializeDocumentByoipCidrEvents(v *[]types.ByoipCidrEvent, value interface{}) error { 6617 if v == nil { 6618 return fmt.Errorf("unexpected nil of type %T", v) 6619 } 6620 if value == nil { 6621 return nil 6622 } 6623 6624 shape, ok := value.([]interface{}) 6625 if !ok { 6626 return fmt.Errorf("unexpected JSON type %v", value) 6627 } 6628 6629 var cv []types.ByoipCidrEvent 6630 if *v == nil { 6631 cv = []types.ByoipCidrEvent{} 6632 } else { 6633 cv = *v 6634 } 6635 6636 for _, value := range shape { 6637 var col types.ByoipCidrEvent 6638 destAddr := &col 6639 if err := awsAwsjson11_deserializeDocumentByoipCidrEvent(&destAddr, value); err != nil { 6640 return err 6641 } 6642 col = *destAddr 6643 cv = append(cv, col) 6644 6645 } 6646 *v = cv 6647 return nil 6648} 6649 6650func awsAwsjson11_deserializeDocumentByoipCidrNotFoundException(v **types.ByoipCidrNotFoundException, value interface{}) error { 6651 if v == nil { 6652 return fmt.Errorf("unexpected nil of type %T", v) 6653 } 6654 if value == nil { 6655 return nil 6656 } 6657 6658 shape, ok := value.(map[string]interface{}) 6659 if !ok { 6660 return fmt.Errorf("unexpected JSON type %v", value) 6661 } 6662 6663 var sv *types.ByoipCidrNotFoundException 6664 if *v == nil { 6665 sv = &types.ByoipCidrNotFoundException{} 6666 } else { 6667 sv = *v 6668 } 6669 6670 for key, value := range shape { 6671 switch key { 6672 case "Message": 6673 if value != nil { 6674 jtv, ok := value.(string) 6675 if !ok { 6676 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6677 } 6678 sv.Message = ptr.String(jtv) 6679 } 6680 6681 default: 6682 _, _ = key, value 6683 6684 } 6685 } 6686 *v = sv 6687 return nil 6688} 6689 6690func awsAwsjson11_deserializeDocumentByoipCidrs(v *[]types.ByoipCidr, value interface{}) error { 6691 if v == nil { 6692 return fmt.Errorf("unexpected nil of type %T", v) 6693 } 6694 if value == nil { 6695 return nil 6696 } 6697 6698 shape, ok := value.([]interface{}) 6699 if !ok { 6700 return fmt.Errorf("unexpected JSON type %v", value) 6701 } 6702 6703 var cv []types.ByoipCidr 6704 if *v == nil { 6705 cv = []types.ByoipCidr{} 6706 } else { 6707 cv = *v 6708 } 6709 6710 for _, value := range shape { 6711 var col types.ByoipCidr 6712 destAddr := &col 6713 if err := awsAwsjson11_deserializeDocumentByoipCidr(&destAddr, value); err != nil { 6714 return err 6715 } 6716 col = *destAddr 6717 cv = append(cv, col) 6718 6719 } 6720 *v = cv 6721 return nil 6722} 6723 6724func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 6725 if v == nil { 6726 return fmt.Errorf("unexpected nil of type %T", v) 6727 } 6728 if value == nil { 6729 return nil 6730 } 6731 6732 shape, ok := value.(map[string]interface{}) 6733 if !ok { 6734 return fmt.Errorf("unexpected JSON type %v", value) 6735 } 6736 6737 var sv *types.ConflictException 6738 if *v == nil { 6739 sv = &types.ConflictException{} 6740 } else { 6741 sv = *v 6742 } 6743 6744 for key, value := range shape { 6745 switch key { 6746 case "Message": 6747 if value != nil { 6748 jtv, ok := value.(string) 6749 if !ok { 6750 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6751 } 6752 sv.Message = ptr.String(jtv) 6753 } 6754 6755 default: 6756 _, _ = key, value 6757 6758 } 6759 } 6760 *v = sv 6761 return nil 6762} 6763 6764func awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(v **types.CustomRoutingAccelerator, 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 sv *types.CustomRoutingAccelerator 6778 if *v == nil { 6779 sv = &types.CustomRoutingAccelerator{} 6780 } else { 6781 sv = *v 6782 } 6783 6784 for key, value := range shape { 6785 switch key { 6786 case "AcceleratorArn": 6787 if value != nil { 6788 jtv, ok := value.(string) 6789 if !ok { 6790 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6791 } 6792 sv.AcceleratorArn = ptr.String(jtv) 6793 } 6794 6795 case "CreatedTime": 6796 if value != nil { 6797 jtv, ok := value.(json.Number) 6798 if !ok { 6799 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6800 } 6801 f64, err := jtv.Float64() 6802 if err != nil { 6803 return err 6804 } 6805 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6806 } 6807 6808 case "DnsName": 6809 if value != nil { 6810 jtv, ok := value.(string) 6811 if !ok { 6812 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6813 } 6814 sv.DnsName = ptr.String(jtv) 6815 } 6816 6817 case "Enabled": 6818 if value != nil { 6819 jtv, ok := value.(bool) 6820 if !ok { 6821 return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value) 6822 } 6823 sv.Enabled = ptr.Bool(jtv) 6824 } 6825 6826 case "IpAddressType": 6827 if value != nil { 6828 jtv, ok := value.(string) 6829 if !ok { 6830 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value) 6831 } 6832 sv.IpAddressType = types.IpAddressType(jtv) 6833 } 6834 6835 case "IpSets": 6836 if err := awsAwsjson11_deserializeDocumentIpSets(&sv.IpSets, value); err != nil { 6837 return err 6838 } 6839 6840 case "LastModifiedTime": 6841 if value != nil { 6842 jtv, ok := value.(json.Number) 6843 if !ok { 6844 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6845 } 6846 f64, err := jtv.Float64() 6847 if err != nil { 6848 return err 6849 } 6850 sv.LastModifiedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6851 } 6852 6853 case "Name": 6854 if value != nil { 6855 jtv, ok := value.(string) 6856 if !ok { 6857 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6858 } 6859 sv.Name = ptr.String(jtv) 6860 } 6861 6862 case "Status": 6863 if value != nil { 6864 jtv, ok := value.(string) 6865 if !ok { 6866 return fmt.Errorf("expected CustomRoutingAcceleratorStatus to be of type string, got %T instead", value) 6867 } 6868 sv.Status = types.CustomRoutingAcceleratorStatus(jtv) 6869 } 6870 6871 default: 6872 _, _ = key, value 6873 6874 } 6875 } 6876 *v = sv 6877 return nil 6878} 6879 6880func awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(v **types.CustomRoutingAcceleratorAttributes, value interface{}) error { 6881 if v == nil { 6882 return fmt.Errorf("unexpected nil of type %T", v) 6883 } 6884 if value == nil { 6885 return nil 6886 } 6887 6888 shape, ok := value.(map[string]interface{}) 6889 if !ok { 6890 return fmt.Errorf("unexpected JSON type %v", value) 6891 } 6892 6893 var sv *types.CustomRoutingAcceleratorAttributes 6894 if *v == nil { 6895 sv = &types.CustomRoutingAcceleratorAttributes{} 6896 } else { 6897 sv = *v 6898 } 6899 6900 for key, value := range shape { 6901 switch key { 6902 case "FlowLogsEnabled": 6903 if value != nil { 6904 jtv, ok := value.(bool) 6905 if !ok { 6906 return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value) 6907 } 6908 sv.FlowLogsEnabled = ptr.Bool(jtv) 6909 } 6910 6911 case "FlowLogsS3Bucket": 6912 if value != nil { 6913 jtv, ok := value.(string) 6914 if !ok { 6915 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6916 } 6917 sv.FlowLogsS3Bucket = ptr.String(jtv) 6918 } 6919 6920 case "FlowLogsS3Prefix": 6921 if value != nil { 6922 jtv, ok := value.(string) 6923 if !ok { 6924 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 6925 } 6926 sv.FlowLogsS3Prefix = ptr.String(jtv) 6927 } 6928 6929 default: 6930 _, _ = key, value 6931 6932 } 6933 } 6934 *v = sv 6935 return nil 6936} 6937 6938func awsAwsjson11_deserializeDocumentCustomRoutingAccelerators(v *[]types.CustomRoutingAccelerator, value interface{}) error { 6939 if v == nil { 6940 return fmt.Errorf("unexpected nil of type %T", v) 6941 } 6942 if value == nil { 6943 return nil 6944 } 6945 6946 shape, ok := value.([]interface{}) 6947 if !ok { 6948 return fmt.Errorf("unexpected JSON type %v", value) 6949 } 6950 6951 var cv []types.CustomRoutingAccelerator 6952 if *v == nil { 6953 cv = []types.CustomRoutingAccelerator{} 6954 } else { 6955 cv = *v 6956 } 6957 6958 for _, value := range shape { 6959 var col types.CustomRoutingAccelerator 6960 destAddr := &col 6961 if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&destAddr, value); err != nil { 6962 return err 6963 } 6964 col = *destAddr 6965 cv = append(cv, col) 6966 6967 } 6968 *v = cv 6969 return nil 6970} 6971 6972func awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescription(v **types.CustomRoutingDestinationDescription, value interface{}) error { 6973 if v == nil { 6974 return fmt.Errorf("unexpected nil of type %T", v) 6975 } 6976 if value == nil { 6977 return nil 6978 } 6979 6980 shape, ok := value.(map[string]interface{}) 6981 if !ok { 6982 return fmt.Errorf("unexpected JSON type %v", value) 6983 } 6984 6985 var sv *types.CustomRoutingDestinationDescription 6986 if *v == nil { 6987 sv = &types.CustomRoutingDestinationDescription{} 6988 } else { 6989 sv = *v 6990 } 6991 6992 for key, value := range shape { 6993 switch key { 6994 case "FromPort": 6995 if value != nil { 6996 jtv, ok := value.(json.Number) 6997 if !ok { 6998 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 6999 } 7000 i64, err := jtv.Int64() 7001 if err != nil { 7002 return err 7003 } 7004 sv.FromPort = ptr.Int32(int32(i64)) 7005 } 7006 7007 case "Protocols": 7008 if err := awsAwsjson11_deserializeDocumentProtocols(&sv.Protocols, value); err != nil { 7009 return err 7010 } 7011 7012 case "ToPort": 7013 if value != nil { 7014 jtv, ok := value.(json.Number) 7015 if !ok { 7016 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 7017 } 7018 i64, err := jtv.Int64() 7019 if err != nil { 7020 return err 7021 } 7022 sv.ToPort = ptr.Int32(int32(i64)) 7023 } 7024 7025 default: 7026 _, _ = key, value 7027 7028 } 7029 } 7030 *v = sv 7031 return nil 7032} 7033 7034func awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescriptions(v *[]types.CustomRoutingDestinationDescription, value interface{}) error { 7035 if v == nil { 7036 return fmt.Errorf("unexpected nil of type %T", v) 7037 } 7038 if value == nil { 7039 return nil 7040 } 7041 7042 shape, ok := value.([]interface{}) 7043 if !ok { 7044 return fmt.Errorf("unexpected JSON type %v", value) 7045 } 7046 7047 var cv []types.CustomRoutingDestinationDescription 7048 if *v == nil { 7049 cv = []types.CustomRoutingDestinationDescription{} 7050 } else { 7051 cv = *v 7052 } 7053 7054 for _, value := range shape { 7055 var col types.CustomRoutingDestinationDescription 7056 destAddr := &col 7057 if err := awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescription(&destAddr, value); err != nil { 7058 return err 7059 } 7060 col = *destAddr 7061 cv = append(cv, col) 7062 7063 } 7064 *v = cv 7065 return nil 7066} 7067 7068func awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescription(v **types.CustomRoutingEndpointDescription, value interface{}) error { 7069 if v == nil { 7070 return fmt.Errorf("unexpected nil of type %T", v) 7071 } 7072 if value == nil { 7073 return nil 7074 } 7075 7076 shape, ok := value.(map[string]interface{}) 7077 if !ok { 7078 return fmt.Errorf("unexpected JSON type %v", value) 7079 } 7080 7081 var sv *types.CustomRoutingEndpointDescription 7082 if *v == nil { 7083 sv = &types.CustomRoutingEndpointDescription{} 7084 } else { 7085 sv = *v 7086 } 7087 7088 for key, value := range shape { 7089 switch key { 7090 case "EndpointId": 7091 if value != nil { 7092 jtv, ok := value.(string) 7093 if !ok { 7094 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7095 } 7096 sv.EndpointId = ptr.String(jtv) 7097 } 7098 7099 default: 7100 _, _ = key, value 7101 7102 } 7103 } 7104 *v = sv 7105 return nil 7106} 7107 7108func awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(v *[]types.CustomRoutingEndpointDescription, value interface{}) error { 7109 if v == nil { 7110 return fmt.Errorf("unexpected nil of type %T", v) 7111 } 7112 if value == nil { 7113 return nil 7114 } 7115 7116 shape, ok := value.([]interface{}) 7117 if !ok { 7118 return fmt.Errorf("unexpected JSON type %v", value) 7119 } 7120 7121 var cv []types.CustomRoutingEndpointDescription 7122 if *v == nil { 7123 cv = []types.CustomRoutingEndpointDescription{} 7124 } else { 7125 cv = *v 7126 } 7127 7128 for _, value := range shape { 7129 var col types.CustomRoutingEndpointDescription 7130 destAddr := &col 7131 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescription(&destAddr, value); err != nil { 7132 return err 7133 } 7134 col = *destAddr 7135 cv = append(cv, col) 7136 7137 } 7138 *v = cv 7139 return nil 7140} 7141 7142func awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(v **types.CustomRoutingEndpointGroup, value interface{}) error { 7143 if v == nil { 7144 return fmt.Errorf("unexpected nil of type %T", v) 7145 } 7146 if value == nil { 7147 return nil 7148 } 7149 7150 shape, ok := value.(map[string]interface{}) 7151 if !ok { 7152 return fmt.Errorf("unexpected JSON type %v", value) 7153 } 7154 7155 var sv *types.CustomRoutingEndpointGroup 7156 if *v == nil { 7157 sv = &types.CustomRoutingEndpointGroup{} 7158 } else { 7159 sv = *v 7160 } 7161 7162 for key, value := range shape { 7163 switch key { 7164 case "DestinationDescriptions": 7165 if err := awsAwsjson11_deserializeDocumentCustomRoutingDestinationDescriptions(&sv.DestinationDescriptions, value); err != nil { 7166 return err 7167 } 7168 7169 case "EndpointDescriptions": 7170 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil { 7171 return err 7172 } 7173 7174 case "EndpointGroupArn": 7175 if value != nil { 7176 jtv, ok := value.(string) 7177 if !ok { 7178 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7179 } 7180 sv.EndpointGroupArn = ptr.String(jtv) 7181 } 7182 7183 case "EndpointGroupRegion": 7184 if value != nil { 7185 jtv, ok := value.(string) 7186 if !ok { 7187 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7188 } 7189 sv.EndpointGroupRegion = ptr.String(jtv) 7190 } 7191 7192 default: 7193 _, _ = key, value 7194 7195 } 7196 } 7197 *v = sv 7198 return nil 7199} 7200 7201func awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroups(v *[]types.CustomRoutingEndpointGroup, value interface{}) error { 7202 if v == nil { 7203 return fmt.Errorf("unexpected nil of type %T", v) 7204 } 7205 if value == nil { 7206 return nil 7207 } 7208 7209 shape, ok := value.([]interface{}) 7210 if !ok { 7211 return fmt.Errorf("unexpected JSON type %v", value) 7212 } 7213 7214 var cv []types.CustomRoutingEndpointGroup 7215 if *v == nil { 7216 cv = []types.CustomRoutingEndpointGroup{} 7217 } else { 7218 cv = *v 7219 } 7220 7221 for _, value := range shape { 7222 var col types.CustomRoutingEndpointGroup 7223 destAddr := &col 7224 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&destAddr, value); err != nil { 7225 return err 7226 } 7227 col = *destAddr 7228 cv = append(cv, col) 7229 7230 } 7231 *v = cv 7232 return nil 7233} 7234 7235func awsAwsjson11_deserializeDocumentCustomRoutingListener(v **types.CustomRoutingListener, value interface{}) error { 7236 if v == nil { 7237 return fmt.Errorf("unexpected nil of type %T", v) 7238 } 7239 if value == nil { 7240 return nil 7241 } 7242 7243 shape, ok := value.(map[string]interface{}) 7244 if !ok { 7245 return fmt.Errorf("unexpected JSON type %v", value) 7246 } 7247 7248 var sv *types.CustomRoutingListener 7249 if *v == nil { 7250 sv = &types.CustomRoutingListener{} 7251 } else { 7252 sv = *v 7253 } 7254 7255 for key, value := range shape { 7256 switch key { 7257 case "ListenerArn": 7258 if value != nil { 7259 jtv, ok := value.(string) 7260 if !ok { 7261 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7262 } 7263 sv.ListenerArn = ptr.String(jtv) 7264 } 7265 7266 case "PortRanges": 7267 if err := awsAwsjson11_deserializeDocumentPortRanges(&sv.PortRanges, value); err != nil { 7268 return err 7269 } 7270 7271 default: 7272 _, _ = key, value 7273 7274 } 7275 } 7276 *v = sv 7277 return nil 7278} 7279 7280func awsAwsjson11_deserializeDocumentCustomRoutingListeners(v *[]types.CustomRoutingListener, value interface{}) error { 7281 if v == nil { 7282 return fmt.Errorf("unexpected nil of type %T", v) 7283 } 7284 if value == nil { 7285 return nil 7286 } 7287 7288 shape, ok := value.([]interface{}) 7289 if !ok { 7290 return fmt.Errorf("unexpected JSON type %v", value) 7291 } 7292 7293 var cv []types.CustomRoutingListener 7294 if *v == nil { 7295 cv = []types.CustomRoutingListener{} 7296 } else { 7297 cv = *v 7298 } 7299 7300 for _, value := range shape { 7301 var col types.CustomRoutingListener 7302 destAddr := &col 7303 if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&destAddr, value); err != nil { 7304 return err 7305 } 7306 col = *destAddr 7307 cv = append(cv, col) 7308 7309 } 7310 *v = cv 7311 return nil 7312} 7313 7314func awsAwsjson11_deserializeDocumentCustomRoutingProtocols(v *[]types.CustomRoutingProtocol, value interface{}) error { 7315 if v == nil { 7316 return fmt.Errorf("unexpected nil of type %T", v) 7317 } 7318 if value == nil { 7319 return nil 7320 } 7321 7322 shape, ok := value.([]interface{}) 7323 if !ok { 7324 return fmt.Errorf("unexpected JSON type %v", value) 7325 } 7326 7327 var cv []types.CustomRoutingProtocol 7328 if *v == nil { 7329 cv = []types.CustomRoutingProtocol{} 7330 } else { 7331 cv = *v 7332 } 7333 7334 for _, value := range shape { 7335 var col types.CustomRoutingProtocol 7336 if value != nil { 7337 jtv, ok := value.(string) 7338 if !ok { 7339 return fmt.Errorf("expected CustomRoutingProtocol to be of type string, got %T instead", value) 7340 } 7341 col = types.CustomRoutingProtocol(jtv) 7342 } 7343 cv = append(cv, col) 7344 7345 } 7346 *v = cv 7347 return nil 7348} 7349 7350func awsAwsjson11_deserializeDocumentDestinationPortMapping(v **types.DestinationPortMapping, value interface{}) error { 7351 if v == nil { 7352 return fmt.Errorf("unexpected nil of type %T", v) 7353 } 7354 if value == nil { 7355 return nil 7356 } 7357 7358 shape, ok := value.(map[string]interface{}) 7359 if !ok { 7360 return fmt.Errorf("unexpected JSON type %v", value) 7361 } 7362 7363 var sv *types.DestinationPortMapping 7364 if *v == nil { 7365 sv = &types.DestinationPortMapping{} 7366 } else { 7367 sv = *v 7368 } 7369 7370 for key, value := range shape { 7371 switch key { 7372 case "AcceleratorArn": 7373 if value != nil { 7374 jtv, ok := value.(string) 7375 if !ok { 7376 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7377 } 7378 sv.AcceleratorArn = ptr.String(jtv) 7379 } 7380 7381 case "AcceleratorSocketAddresses": 7382 if err := awsAwsjson11_deserializeDocumentSocketAddresses(&sv.AcceleratorSocketAddresses, value); err != nil { 7383 return err 7384 } 7385 7386 case "DestinationSocketAddress": 7387 if err := awsAwsjson11_deserializeDocumentSocketAddress(&sv.DestinationSocketAddress, value); err != nil { 7388 return err 7389 } 7390 7391 case "DestinationTrafficState": 7392 if value != nil { 7393 jtv, ok := value.(string) 7394 if !ok { 7395 return fmt.Errorf("expected CustomRoutingDestinationTrafficState to be of type string, got %T instead", value) 7396 } 7397 sv.DestinationTrafficState = types.CustomRoutingDestinationTrafficState(jtv) 7398 } 7399 7400 case "EndpointGroupArn": 7401 if value != nil { 7402 jtv, ok := value.(string) 7403 if !ok { 7404 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7405 } 7406 sv.EndpointGroupArn = ptr.String(jtv) 7407 } 7408 7409 case "EndpointGroupRegion": 7410 if value != nil { 7411 jtv, ok := value.(string) 7412 if !ok { 7413 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7414 } 7415 sv.EndpointGroupRegion = ptr.String(jtv) 7416 } 7417 7418 case "EndpointId": 7419 if value != nil { 7420 jtv, ok := value.(string) 7421 if !ok { 7422 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7423 } 7424 sv.EndpointId = ptr.String(jtv) 7425 } 7426 7427 case "IpAddressType": 7428 if value != nil { 7429 jtv, ok := value.(string) 7430 if !ok { 7431 return fmt.Errorf("expected IpAddressType to be of type string, got %T instead", value) 7432 } 7433 sv.IpAddressType = types.IpAddressType(jtv) 7434 } 7435 7436 default: 7437 _, _ = key, value 7438 7439 } 7440 } 7441 *v = sv 7442 return nil 7443} 7444 7445func awsAwsjson11_deserializeDocumentDestinationPortMappings(v *[]types.DestinationPortMapping, value interface{}) error { 7446 if v == nil { 7447 return fmt.Errorf("unexpected nil of type %T", v) 7448 } 7449 if value == nil { 7450 return nil 7451 } 7452 7453 shape, ok := value.([]interface{}) 7454 if !ok { 7455 return fmt.Errorf("unexpected JSON type %v", value) 7456 } 7457 7458 var cv []types.DestinationPortMapping 7459 if *v == nil { 7460 cv = []types.DestinationPortMapping{} 7461 } else { 7462 cv = *v 7463 } 7464 7465 for _, value := range shape { 7466 var col types.DestinationPortMapping 7467 destAddr := &col 7468 if err := awsAwsjson11_deserializeDocumentDestinationPortMapping(&destAddr, value); err != nil { 7469 return err 7470 } 7471 col = *destAddr 7472 cv = append(cv, col) 7473 7474 } 7475 *v = cv 7476 return nil 7477} 7478 7479func awsAwsjson11_deserializeDocumentEndpointAlreadyExistsException(v **types.EndpointAlreadyExistsException, value interface{}) error { 7480 if v == nil { 7481 return fmt.Errorf("unexpected nil of type %T", v) 7482 } 7483 if value == nil { 7484 return nil 7485 } 7486 7487 shape, ok := value.(map[string]interface{}) 7488 if !ok { 7489 return fmt.Errorf("unexpected JSON type %v", value) 7490 } 7491 7492 var sv *types.EndpointAlreadyExistsException 7493 if *v == nil { 7494 sv = &types.EndpointAlreadyExistsException{} 7495 } else { 7496 sv = *v 7497 } 7498 7499 for key, value := range shape { 7500 switch key { 7501 case "Message": 7502 if value != nil { 7503 jtv, ok := value.(string) 7504 if !ok { 7505 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7506 } 7507 sv.Message = ptr.String(jtv) 7508 } 7509 7510 default: 7511 _, _ = key, value 7512 7513 } 7514 } 7515 *v = sv 7516 return nil 7517} 7518 7519func awsAwsjson11_deserializeDocumentEndpointDescription(v **types.EndpointDescription, value interface{}) error { 7520 if v == nil { 7521 return fmt.Errorf("unexpected nil of type %T", v) 7522 } 7523 if value == nil { 7524 return nil 7525 } 7526 7527 shape, ok := value.(map[string]interface{}) 7528 if !ok { 7529 return fmt.Errorf("unexpected JSON type %v", value) 7530 } 7531 7532 var sv *types.EndpointDescription 7533 if *v == nil { 7534 sv = &types.EndpointDescription{} 7535 } else { 7536 sv = *v 7537 } 7538 7539 for key, value := range shape { 7540 switch key { 7541 case "ClientIPPreservationEnabled": 7542 if value != nil { 7543 jtv, ok := value.(bool) 7544 if !ok { 7545 return fmt.Errorf("expected GenericBoolean to be of type *bool, got %T instead", value) 7546 } 7547 sv.ClientIPPreservationEnabled = ptr.Bool(jtv) 7548 } 7549 7550 case "EndpointId": 7551 if value != nil { 7552 jtv, ok := value.(string) 7553 if !ok { 7554 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7555 } 7556 sv.EndpointId = ptr.String(jtv) 7557 } 7558 7559 case "HealthReason": 7560 if value != nil { 7561 jtv, ok := value.(string) 7562 if !ok { 7563 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7564 } 7565 sv.HealthReason = ptr.String(jtv) 7566 } 7567 7568 case "HealthState": 7569 if value != nil { 7570 jtv, ok := value.(string) 7571 if !ok { 7572 return fmt.Errorf("expected HealthState to be of type string, got %T instead", value) 7573 } 7574 sv.HealthState = types.HealthState(jtv) 7575 } 7576 7577 case "Weight": 7578 if value != nil { 7579 jtv, ok := value.(json.Number) 7580 if !ok { 7581 return fmt.Errorf("expected EndpointWeight to be json.Number, got %T instead", value) 7582 } 7583 i64, err := jtv.Int64() 7584 if err != nil { 7585 return err 7586 } 7587 sv.Weight = ptr.Int32(int32(i64)) 7588 } 7589 7590 default: 7591 _, _ = key, value 7592 7593 } 7594 } 7595 *v = sv 7596 return nil 7597} 7598 7599func awsAwsjson11_deserializeDocumentEndpointDescriptions(v *[]types.EndpointDescription, value interface{}) error { 7600 if v == nil { 7601 return fmt.Errorf("unexpected nil of type %T", v) 7602 } 7603 if value == nil { 7604 return nil 7605 } 7606 7607 shape, ok := value.([]interface{}) 7608 if !ok { 7609 return fmt.Errorf("unexpected JSON type %v", value) 7610 } 7611 7612 var cv []types.EndpointDescription 7613 if *v == nil { 7614 cv = []types.EndpointDescription{} 7615 } else { 7616 cv = *v 7617 } 7618 7619 for _, value := range shape { 7620 var col types.EndpointDescription 7621 destAddr := &col 7622 if err := awsAwsjson11_deserializeDocumentEndpointDescription(&destAddr, value); err != nil { 7623 return err 7624 } 7625 col = *destAddr 7626 cv = append(cv, col) 7627 7628 } 7629 *v = cv 7630 return nil 7631} 7632 7633func awsAwsjson11_deserializeDocumentEndpointGroup(v **types.EndpointGroup, value interface{}) error { 7634 if v == nil { 7635 return fmt.Errorf("unexpected nil of type %T", v) 7636 } 7637 if value == nil { 7638 return nil 7639 } 7640 7641 shape, ok := value.(map[string]interface{}) 7642 if !ok { 7643 return fmt.Errorf("unexpected JSON type %v", value) 7644 } 7645 7646 var sv *types.EndpointGroup 7647 if *v == nil { 7648 sv = &types.EndpointGroup{} 7649 } else { 7650 sv = *v 7651 } 7652 7653 for key, value := range shape { 7654 switch key { 7655 case "EndpointDescriptions": 7656 if err := awsAwsjson11_deserializeDocumentEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil { 7657 return err 7658 } 7659 7660 case "EndpointGroupArn": 7661 if value != nil { 7662 jtv, ok := value.(string) 7663 if !ok { 7664 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7665 } 7666 sv.EndpointGroupArn = ptr.String(jtv) 7667 } 7668 7669 case "EndpointGroupRegion": 7670 if value != nil { 7671 jtv, ok := value.(string) 7672 if !ok { 7673 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 7674 } 7675 sv.EndpointGroupRegion = ptr.String(jtv) 7676 } 7677 7678 case "HealthCheckIntervalSeconds": 7679 if value != nil { 7680 jtv, ok := value.(json.Number) 7681 if !ok { 7682 return fmt.Errorf("expected HealthCheckIntervalSeconds to be json.Number, got %T instead", value) 7683 } 7684 i64, err := jtv.Int64() 7685 if err != nil { 7686 return err 7687 } 7688 sv.HealthCheckIntervalSeconds = ptr.Int32(int32(i64)) 7689 } 7690 7691 case "HealthCheckPath": 7692 if value != nil { 7693 jtv, ok := value.(string) 7694 if !ok { 7695 return fmt.Errorf("expected HealthCheckPath to be of type string, got %T instead", value) 7696 } 7697 sv.HealthCheckPath = ptr.String(jtv) 7698 } 7699 7700 case "HealthCheckPort": 7701 if value != nil { 7702 jtv, ok := value.(json.Number) 7703 if !ok { 7704 return fmt.Errorf("expected HealthCheckPort to be json.Number, got %T instead", value) 7705 } 7706 i64, err := jtv.Int64() 7707 if err != nil { 7708 return err 7709 } 7710 sv.HealthCheckPort = ptr.Int32(int32(i64)) 7711 } 7712 7713 case "HealthCheckProtocol": 7714 if value != nil { 7715 jtv, ok := value.(string) 7716 if !ok { 7717 return fmt.Errorf("expected HealthCheckProtocol to be of type string, got %T instead", value) 7718 } 7719 sv.HealthCheckProtocol = types.HealthCheckProtocol(jtv) 7720 } 7721 7722 case "PortOverrides": 7723 if err := awsAwsjson11_deserializeDocumentPortOverrides(&sv.PortOverrides, value); err != nil { 7724 return err 7725 } 7726 7727 case "ThresholdCount": 7728 if value != nil { 7729 jtv, ok := value.(json.Number) 7730 if !ok { 7731 return fmt.Errorf("expected ThresholdCount to be json.Number, got %T instead", value) 7732 } 7733 i64, err := jtv.Int64() 7734 if err != nil { 7735 return err 7736 } 7737 sv.ThresholdCount = ptr.Int32(int32(i64)) 7738 } 7739 7740 case "TrafficDialPercentage": 7741 if value != nil { 7742 jtv, ok := value.(json.Number) 7743 if !ok { 7744 return fmt.Errorf("expected TrafficDialPercentage to be json.Number, got %T instead", value) 7745 } 7746 f64, err := jtv.Float64() 7747 if err != nil { 7748 return err 7749 } 7750 sv.TrafficDialPercentage = ptr.Float32(float32(f64)) 7751 } 7752 7753 default: 7754 _, _ = key, value 7755 7756 } 7757 } 7758 *v = sv 7759 return nil 7760} 7761 7762func awsAwsjson11_deserializeDocumentEndpointGroupAlreadyExistsException(v **types.EndpointGroupAlreadyExistsException, value interface{}) error { 7763 if v == nil { 7764 return fmt.Errorf("unexpected nil of type %T", v) 7765 } 7766 if value == nil { 7767 return nil 7768 } 7769 7770 shape, ok := value.(map[string]interface{}) 7771 if !ok { 7772 return fmt.Errorf("unexpected JSON type %v", value) 7773 } 7774 7775 var sv *types.EndpointGroupAlreadyExistsException 7776 if *v == nil { 7777 sv = &types.EndpointGroupAlreadyExistsException{} 7778 } else { 7779 sv = *v 7780 } 7781 7782 for key, value := range shape { 7783 switch key { 7784 case "Message": 7785 if value != nil { 7786 jtv, ok := value.(string) 7787 if !ok { 7788 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7789 } 7790 sv.Message = ptr.String(jtv) 7791 } 7792 7793 default: 7794 _, _ = key, value 7795 7796 } 7797 } 7798 *v = sv 7799 return nil 7800} 7801 7802func awsAwsjson11_deserializeDocumentEndpointGroupNotFoundException(v **types.EndpointGroupNotFoundException, value interface{}) error { 7803 if v == nil { 7804 return fmt.Errorf("unexpected nil of type %T", v) 7805 } 7806 if value == nil { 7807 return nil 7808 } 7809 7810 shape, ok := value.(map[string]interface{}) 7811 if !ok { 7812 return fmt.Errorf("unexpected JSON type %v", value) 7813 } 7814 7815 var sv *types.EndpointGroupNotFoundException 7816 if *v == nil { 7817 sv = &types.EndpointGroupNotFoundException{} 7818 } else { 7819 sv = *v 7820 } 7821 7822 for key, value := range shape { 7823 switch key { 7824 case "Message": 7825 if value != nil { 7826 jtv, ok := value.(string) 7827 if !ok { 7828 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7829 } 7830 sv.Message = ptr.String(jtv) 7831 } 7832 7833 default: 7834 _, _ = key, value 7835 7836 } 7837 } 7838 *v = sv 7839 return nil 7840} 7841 7842func awsAwsjson11_deserializeDocumentEndpointGroups(v *[]types.EndpointGroup, value interface{}) error { 7843 if v == nil { 7844 return fmt.Errorf("unexpected nil of type %T", v) 7845 } 7846 if value == nil { 7847 return nil 7848 } 7849 7850 shape, ok := value.([]interface{}) 7851 if !ok { 7852 return fmt.Errorf("unexpected JSON type %v", value) 7853 } 7854 7855 var cv []types.EndpointGroup 7856 if *v == nil { 7857 cv = []types.EndpointGroup{} 7858 } else { 7859 cv = *v 7860 } 7861 7862 for _, value := range shape { 7863 var col types.EndpointGroup 7864 destAddr := &col 7865 if err := awsAwsjson11_deserializeDocumentEndpointGroup(&destAddr, value); err != nil { 7866 return err 7867 } 7868 col = *destAddr 7869 cv = append(cv, col) 7870 7871 } 7872 *v = cv 7873 return nil 7874} 7875 7876func awsAwsjson11_deserializeDocumentEndpointNotFoundException(v **types.EndpointNotFoundException, value interface{}) error { 7877 if v == nil { 7878 return fmt.Errorf("unexpected nil of type %T", v) 7879 } 7880 if value == nil { 7881 return nil 7882 } 7883 7884 shape, ok := value.(map[string]interface{}) 7885 if !ok { 7886 return fmt.Errorf("unexpected JSON type %v", value) 7887 } 7888 7889 var sv *types.EndpointNotFoundException 7890 if *v == nil { 7891 sv = &types.EndpointNotFoundException{} 7892 } else { 7893 sv = *v 7894 } 7895 7896 for key, value := range shape { 7897 switch key { 7898 case "Message": 7899 if value != nil { 7900 jtv, ok := value.(string) 7901 if !ok { 7902 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7903 } 7904 sv.Message = ptr.String(jtv) 7905 } 7906 7907 default: 7908 _, _ = key, value 7909 7910 } 7911 } 7912 *v = sv 7913 return nil 7914} 7915 7916func awsAwsjson11_deserializeDocumentIncorrectCidrStateException(v **types.IncorrectCidrStateException, value interface{}) error { 7917 if v == nil { 7918 return fmt.Errorf("unexpected nil of type %T", v) 7919 } 7920 if value == nil { 7921 return nil 7922 } 7923 7924 shape, ok := value.(map[string]interface{}) 7925 if !ok { 7926 return fmt.Errorf("unexpected JSON type %v", value) 7927 } 7928 7929 var sv *types.IncorrectCidrStateException 7930 if *v == nil { 7931 sv = &types.IncorrectCidrStateException{} 7932 } else { 7933 sv = *v 7934 } 7935 7936 for key, value := range shape { 7937 switch key { 7938 case "Message": 7939 if value != nil { 7940 jtv, ok := value.(string) 7941 if !ok { 7942 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7943 } 7944 sv.Message = ptr.String(jtv) 7945 } 7946 7947 default: 7948 _, _ = key, value 7949 7950 } 7951 } 7952 *v = sv 7953 return nil 7954} 7955 7956func awsAwsjson11_deserializeDocumentInternalServiceErrorException(v **types.InternalServiceErrorException, value interface{}) error { 7957 if v == nil { 7958 return fmt.Errorf("unexpected nil of type %T", v) 7959 } 7960 if value == nil { 7961 return nil 7962 } 7963 7964 shape, ok := value.(map[string]interface{}) 7965 if !ok { 7966 return fmt.Errorf("unexpected JSON type %v", value) 7967 } 7968 7969 var sv *types.InternalServiceErrorException 7970 if *v == nil { 7971 sv = &types.InternalServiceErrorException{} 7972 } else { 7973 sv = *v 7974 } 7975 7976 for key, value := range shape { 7977 switch key { 7978 case "Message": 7979 if value != nil { 7980 jtv, ok := value.(string) 7981 if !ok { 7982 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7983 } 7984 sv.Message = ptr.String(jtv) 7985 } 7986 7987 default: 7988 _, _ = key, value 7989 7990 } 7991 } 7992 *v = sv 7993 return nil 7994} 7995 7996func awsAwsjson11_deserializeDocumentInvalidArgumentException(v **types.InvalidArgumentException, value interface{}) error { 7997 if v == nil { 7998 return fmt.Errorf("unexpected nil of type %T", v) 7999 } 8000 if value == nil { 8001 return nil 8002 } 8003 8004 shape, ok := value.(map[string]interface{}) 8005 if !ok { 8006 return fmt.Errorf("unexpected JSON type %v", value) 8007 } 8008 8009 var sv *types.InvalidArgumentException 8010 if *v == nil { 8011 sv = &types.InvalidArgumentException{} 8012 } else { 8013 sv = *v 8014 } 8015 8016 for key, value := range shape { 8017 switch key { 8018 case "Message": 8019 if value != nil { 8020 jtv, ok := value.(string) 8021 if !ok { 8022 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8023 } 8024 sv.Message = ptr.String(jtv) 8025 } 8026 8027 default: 8028 _, _ = key, value 8029 8030 } 8031 } 8032 *v = sv 8033 return nil 8034} 8035 8036func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 8037 if v == nil { 8038 return fmt.Errorf("unexpected nil of type %T", v) 8039 } 8040 if value == nil { 8041 return nil 8042 } 8043 8044 shape, ok := value.(map[string]interface{}) 8045 if !ok { 8046 return fmt.Errorf("unexpected JSON type %v", value) 8047 } 8048 8049 var sv *types.InvalidNextTokenException 8050 if *v == nil { 8051 sv = &types.InvalidNextTokenException{} 8052 } else { 8053 sv = *v 8054 } 8055 8056 for key, value := range shape { 8057 switch key { 8058 case "Message": 8059 if value != nil { 8060 jtv, ok := value.(string) 8061 if !ok { 8062 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8063 } 8064 sv.Message = ptr.String(jtv) 8065 } 8066 8067 default: 8068 _, _ = key, value 8069 8070 } 8071 } 8072 *v = sv 8073 return nil 8074} 8075 8076func awsAwsjson11_deserializeDocumentInvalidPortRangeException(v **types.InvalidPortRangeException, value interface{}) error { 8077 if v == nil { 8078 return fmt.Errorf("unexpected nil of type %T", v) 8079 } 8080 if value == nil { 8081 return nil 8082 } 8083 8084 shape, ok := value.(map[string]interface{}) 8085 if !ok { 8086 return fmt.Errorf("unexpected JSON type %v", value) 8087 } 8088 8089 var sv *types.InvalidPortRangeException 8090 if *v == nil { 8091 sv = &types.InvalidPortRangeException{} 8092 } else { 8093 sv = *v 8094 } 8095 8096 for key, value := range shape { 8097 switch key { 8098 case "Message": 8099 if value != nil { 8100 jtv, ok := value.(string) 8101 if !ok { 8102 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8103 } 8104 sv.Message = ptr.String(jtv) 8105 } 8106 8107 default: 8108 _, _ = key, value 8109 8110 } 8111 } 8112 *v = sv 8113 return nil 8114} 8115 8116func awsAwsjson11_deserializeDocumentIpAddresses(v *[]string, value interface{}) error { 8117 if v == nil { 8118 return fmt.Errorf("unexpected nil of type %T", v) 8119 } 8120 if value == nil { 8121 return nil 8122 } 8123 8124 shape, ok := value.([]interface{}) 8125 if !ok { 8126 return fmt.Errorf("unexpected JSON type %v", value) 8127 } 8128 8129 var cv []string 8130 if *v == nil { 8131 cv = []string{} 8132 } else { 8133 cv = *v 8134 } 8135 8136 for _, value := range shape { 8137 var col string 8138 if value != nil { 8139 jtv, ok := value.(string) 8140 if !ok { 8141 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value) 8142 } 8143 col = jtv 8144 } 8145 cv = append(cv, col) 8146 8147 } 8148 *v = cv 8149 return nil 8150} 8151 8152func awsAwsjson11_deserializeDocumentIpSet(v **types.IpSet, value interface{}) error { 8153 if v == nil { 8154 return fmt.Errorf("unexpected nil of type %T", v) 8155 } 8156 if value == nil { 8157 return nil 8158 } 8159 8160 shape, ok := value.(map[string]interface{}) 8161 if !ok { 8162 return fmt.Errorf("unexpected JSON type %v", value) 8163 } 8164 8165 var sv *types.IpSet 8166 if *v == nil { 8167 sv = &types.IpSet{} 8168 } else { 8169 sv = *v 8170 } 8171 8172 for key, value := range shape { 8173 switch key { 8174 case "IpAddresses": 8175 if err := awsAwsjson11_deserializeDocumentIpAddresses(&sv.IpAddresses, value); err != nil { 8176 return err 8177 } 8178 8179 case "IpFamily": 8180 if value != nil { 8181 jtv, ok := value.(string) 8182 if !ok { 8183 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8184 } 8185 sv.IpFamily = ptr.String(jtv) 8186 } 8187 8188 default: 8189 _, _ = key, value 8190 8191 } 8192 } 8193 *v = sv 8194 return nil 8195} 8196 8197func awsAwsjson11_deserializeDocumentIpSets(v *[]types.IpSet, value interface{}) error { 8198 if v == nil { 8199 return fmt.Errorf("unexpected nil of type %T", v) 8200 } 8201 if value == nil { 8202 return nil 8203 } 8204 8205 shape, ok := value.([]interface{}) 8206 if !ok { 8207 return fmt.Errorf("unexpected JSON type %v", value) 8208 } 8209 8210 var cv []types.IpSet 8211 if *v == nil { 8212 cv = []types.IpSet{} 8213 } else { 8214 cv = *v 8215 } 8216 8217 for _, value := range shape { 8218 var col types.IpSet 8219 destAddr := &col 8220 if err := awsAwsjson11_deserializeDocumentIpSet(&destAddr, value); err != nil { 8221 return err 8222 } 8223 col = *destAddr 8224 cv = append(cv, col) 8225 8226 } 8227 *v = cv 8228 return nil 8229} 8230 8231func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 8232 if v == nil { 8233 return fmt.Errorf("unexpected nil of type %T", v) 8234 } 8235 if value == nil { 8236 return nil 8237 } 8238 8239 shape, ok := value.(map[string]interface{}) 8240 if !ok { 8241 return fmt.Errorf("unexpected JSON type %v", value) 8242 } 8243 8244 var sv *types.LimitExceededException 8245 if *v == nil { 8246 sv = &types.LimitExceededException{} 8247 } else { 8248 sv = *v 8249 } 8250 8251 for key, value := range shape { 8252 switch key { 8253 case "Message": 8254 if value != nil { 8255 jtv, ok := value.(string) 8256 if !ok { 8257 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8258 } 8259 sv.Message = ptr.String(jtv) 8260 } 8261 8262 default: 8263 _, _ = key, value 8264 8265 } 8266 } 8267 *v = sv 8268 return nil 8269} 8270 8271func awsAwsjson11_deserializeDocumentListener(v **types.Listener, value interface{}) error { 8272 if v == nil { 8273 return fmt.Errorf("unexpected nil of type %T", v) 8274 } 8275 if value == nil { 8276 return nil 8277 } 8278 8279 shape, ok := value.(map[string]interface{}) 8280 if !ok { 8281 return fmt.Errorf("unexpected JSON type %v", value) 8282 } 8283 8284 var sv *types.Listener 8285 if *v == nil { 8286 sv = &types.Listener{} 8287 } else { 8288 sv = *v 8289 } 8290 8291 for key, value := range shape { 8292 switch key { 8293 case "ClientAffinity": 8294 if value != nil { 8295 jtv, ok := value.(string) 8296 if !ok { 8297 return fmt.Errorf("expected ClientAffinity to be of type string, got %T instead", value) 8298 } 8299 sv.ClientAffinity = types.ClientAffinity(jtv) 8300 } 8301 8302 case "ListenerArn": 8303 if value != nil { 8304 jtv, ok := value.(string) 8305 if !ok { 8306 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8307 } 8308 sv.ListenerArn = ptr.String(jtv) 8309 } 8310 8311 case "PortRanges": 8312 if err := awsAwsjson11_deserializeDocumentPortRanges(&sv.PortRanges, value); err != nil { 8313 return err 8314 } 8315 8316 case "Protocol": 8317 if value != nil { 8318 jtv, ok := value.(string) 8319 if !ok { 8320 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 8321 } 8322 sv.Protocol = types.Protocol(jtv) 8323 } 8324 8325 default: 8326 _, _ = key, value 8327 8328 } 8329 } 8330 *v = sv 8331 return nil 8332} 8333 8334func awsAwsjson11_deserializeDocumentListenerNotFoundException(v **types.ListenerNotFoundException, value interface{}) error { 8335 if v == nil { 8336 return fmt.Errorf("unexpected nil of type %T", v) 8337 } 8338 if value == nil { 8339 return nil 8340 } 8341 8342 shape, ok := value.(map[string]interface{}) 8343 if !ok { 8344 return fmt.Errorf("unexpected JSON type %v", value) 8345 } 8346 8347 var sv *types.ListenerNotFoundException 8348 if *v == nil { 8349 sv = &types.ListenerNotFoundException{} 8350 } else { 8351 sv = *v 8352 } 8353 8354 for key, value := range shape { 8355 switch key { 8356 case "Message": 8357 if value != nil { 8358 jtv, ok := value.(string) 8359 if !ok { 8360 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8361 } 8362 sv.Message = ptr.String(jtv) 8363 } 8364 8365 default: 8366 _, _ = key, value 8367 8368 } 8369 } 8370 *v = sv 8371 return nil 8372} 8373 8374func awsAwsjson11_deserializeDocumentListeners(v *[]types.Listener, value interface{}) error { 8375 if v == nil { 8376 return fmt.Errorf("unexpected nil of type %T", v) 8377 } 8378 if value == nil { 8379 return nil 8380 } 8381 8382 shape, ok := value.([]interface{}) 8383 if !ok { 8384 return fmt.Errorf("unexpected JSON type %v", value) 8385 } 8386 8387 var cv []types.Listener 8388 if *v == nil { 8389 cv = []types.Listener{} 8390 } else { 8391 cv = *v 8392 } 8393 8394 for _, value := range shape { 8395 var col types.Listener 8396 destAddr := &col 8397 if err := awsAwsjson11_deserializeDocumentListener(&destAddr, value); err != nil { 8398 return err 8399 } 8400 col = *destAddr 8401 cv = append(cv, col) 8402 8403 } 8404 *v = cv 8405 return nil 8406} 8407 8408func awsAwsjson11_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error { 8409 if v == nil { 8410 return fmt.Errorf("unexpected nil of type %T", v) 8411 } 8412 if value == nil { 8413 return nil 8414 } 8415 8416 shape, ok := value.(map[string]interface{}) 8417 if !ok { 8418 return fmt.Errorf("unexpected JSON type %v", value) 8419 } 8420 8421 var sv *types.PortMapping 8422 if *v == nil { 8423 sv = &types.PortMapping{} 8424 } else { 8425 sv = *v 8426 } 8427 8428 for key, value := range shape { 8429 switch key { 8430 case "AcceleratorPort": 8431 if value != nil { 8432 jtv, ok := value.(json.Number) 8433 if !ok { 8434 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8435 } 8436 i64, err := jtv.Int64() 8437 if err != nil { 8438 return err 8439 } 8440 sv.AcceleratorPort = ptr.Int32(int32(i64)) 8441 } 8442 8443 case "DestinationSocketAddress": 8444 if err := awsAwsjson11_deserializeDocumentSocketAddress(&sv.DestinationSocketAddress, value); err != nil { 8445 return err 8446 } 8447 8448 case "DestinationTrafficState": 8449 if value != nil { 8450 jtv, ok := value.(string) 8451 if !ok { 8452 return fmt.Errorf("expected CustomRoutingDestinationTrafficState to be of type string, got %T instead", value) 8453 } 8454 sv.DestinationTrafficState = types.CustomRoutingDestinationTrafficState(jtv) 8455 } 8456 8457 case "EndpointGroupArn": 8458 if value != nil { 8459 jtv, ok := value.(string) 8460 if !ok { 8461 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8462 } 8463 sv.EndpointGroupArn = ptr.String(jtv) 8464 } 8465 8466 case "EndpointId": 8467 if value != nil { 8468 jtv, ok := value.(string) 8469 if !ok { 8470 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8471 } 8472 sv.EndpointId = ptr.String(jtv) 8473 } 8474 8475 case "Protocols": 8476 if err := awsAwsjson11_deserializeDocumentCustomRoutingProtocols(&sv.Protocols, value); err != nil { 8477 return err 8478 } 8479 8480 default: 8481 _, _ = key, value 8482 8483 } 8484 } 8485 *v = sv 8486 return nil 8487} 8488 8489func awsAwsjson11_deserializeDocumentPortMappings(v *[]types.PortMapping, value interface{}) error { 8490 if v == nil { 8491 return fmt.Errorf("unexpected nil of type %T", v) 8492 } 8493 if value == nil { 8494 return nil 8495 } 8496 8497 shape, ok := value.([]interface{}) 8498 if !ok { 8499 return fmt.Errorf("unexpected JSON type %v", value) 8500 } 8501 8502 var cv []types.PortMapping 8503 if *v == nil { 8504 cv = []types.PortMapping{} 8505 } else { 8506 cv = *v 8507 } 8508 8509 for _, value := range shape { 8510 var col types.PortMapping 8511 destAddr := &col 8512 if err := awsAwsjson11_deserializeDocumentPortMapping(&destAddr, value); err != nil { 8513 return err 8514 } 8515 col = *destAddr 8516 cv = append(cv, col) 8517 8518 } 8519 *v = cv 8520 return nil 8521} 8522 8523func awsAwsjson11_deserializeDocumentPortOverride(v **types.PortOverride, value interface{}) error { 8524 if v == nil { 8525 return fmt.Errorf("unexpected nil of type %T", v) 8526 } 8527 if value == nil { 8528 return nil 8529 } 8530 8531 shape, ok := value.(map[string]interface{}) 8532 if !ok { 8533 return fmt.Errorf("unexpected JSON type %v", value) 8534 } 8535 8536 var sv *types.PortOverride 8537 if *v == nil { 8538 sv = &types.PortOverride{} 8539 } else { 8540 sv = *v 8541 } 8542 8543 for key, value := range shape { 8544 switch key { 8545 case "EndpointPort": 8546 if value != nil { 8547 jtv, ok := value.(json.Number) 8548 if !ok { 8549 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8550 } 8551 i64, err := jtv.Int64() 8552 if err != nil { 8553 return err 8554 } 8555 sv.EndpointPort = ptr.Int32(int32(i64)) 8556 } 8557 8558 case "ListenerPort": 8559 if value != nil { 8560 jtv, ok := value.(json.Number) 8561 if !ok { 8562 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8563 } 8564 i64, err := jtv.Int64() 8565 if err != nil { 8566 return err 8567 } 8568 sv.ListenerPort = ptr.Int32(int32(i64)) 8569 } 8570 8571 default: 8572 _, _ = key, value 8573 8574 } 8575 } 8576 *v = sv 8577 return nil 8578} 8579 8580func awsAwsjson11_deserializeDocumentPortOverrides(v *[]types.PortOverride, value interface{}) error { 8581 if v == nil { 8582 return fmt.Errorf("unexpected nil of type %T", v) 8583 } 8584 if value == nil { 8585 return nil 8586 } 8587 8588 shape, ok := value.([]interface{}) 8589 if !ok { 8590 return fmt.Errorf("unexpected JSON type %v", value) 8591 } 8592 8593 var cv []types.PortOverride 8594 if *v == nil { 8595 cv = []types.PortOverride{} 8596 } else { 8597 cv = *v 8598 } 8599 8600 for _, value := range shape { 8601 var col types.PortOverride 8602 destAddr := &col 8603 if err := awsAwsjson11_deserializeDocumentPortOverride(&destAddr, value); err != nil { 8604 return err 8605 } 8606 col = *destAddr 8607 cv = append(cv, col) 8608 8609 } 8610 *v = cv 8611 return nil 8612} 8613 8614func awsAwsjson11_deserializeDocumentPortRange(v **types.PortRange, value interface{}) error { 8615 if v == nil { 8616 return fmt.Errorf("unexpected nil of type %T", v) 8617 } 8618 if value == nil { 8619 return nil 8620 } 8621 8622 shape, ok := value.(map[string]interface{}) 8623 if !ok { 8624 return fmt.Errorf("unexpected JSON type %v", value) 8625 } 8626 8627 var sv *types.PortRange 8628 if *v == nil { 8629 sv = &types.PortRange{} 8630 } else { 8631 sv = *v 8632 } 8633 8634 for key, value := range shape { 8635 switch key { 8636 case "FromPort": 8637 if value != nil { 8638 jtv, ok := value.(json.Number) 8639 if !ok { 8640 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8641 } 8642 i64, err := jtv.Int64() 8643 if err != nil { 8644 return err 8645 } 8646 sv.FromPort = ptr.Int32(int32(i64)) 8647 } 8648 8649 case "ToPort": 8650 if value != nil { 8651 jtv, ok := value.(json.Number) 8652 if !ok { 8653 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8654 } 8655 i64, err := jtv.Int64() 8656 if err != nil { 8657 return err 8658 } 8659 sv.ToPort = ptr.Int32(int32(i64)) 8660 } 8661 8662 default: 8663 _, _ = key, value 8664 8665 } 8666 } 8667 *v = sv 8668 return nil 8669} 8670 8671func awsAwsjson11_deserializeDocumentPortRanges(v *[]types.PortRange, value interface{}) error { 8672 if v == nil { 8673 return fmt.Errorf("unexpected nil of type %T", v) 8674 } 8675 if value == nil { 8676 return nil 8677 } 8678 8679 shape, ok := value.([]interface{}) 8680 if !ok { 8681 return fmt.Errorf("unexpected JSON type %v", value) 8682 } 8683 8684 var cv []types.PortRange 8685 if *v == nil { 8686 cv = []types.PortRange{} 8687 } else { 8688 cv = *v 8689 } 8690 8691 for _, value := range shape { 8692 var col types.PortRange 8693 destAddr := &col 8694 if err := awsAwsjson11_deserializeDocumentPortRange(&destAddr, value); err != nil { 8695 return err 8696 } 8697 col = *destAddr 8698 cv = append(cv, col) 8699 8700 } 8701 *v = cv 8702 return nil 8703} 8704 8705func awsAwsjson11_deserializeDocumentProtocols(v *[]types.Protocol, value interface{}) error { 8706 if v == nil { 8707 return fmt.Errorf("unexpected nil of type %T", v) 8708 } 8709 if value == nil { 8710 return nil 8711 } 8712 8713 shape, ok := value.([]interface{}) 8714 if !ok { 8715 return fmt.Errorf("unexpected JSON type %v", value) 8716 } 8717 8718 var cv []types.Protocol 8719 if *v == nil { 8720 cv = []types.Protocol{} 8721 } else { 8722 cv = *v 8723 } 8724 8725 for _, value := range shape { 8726 var col types.Protocol 8727 if value != nil { 8728 jtv, ok := value.(string) 8729 if !ok { 8730 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 8731 } 8732 col = types.Protocol(jtv) 8733 } 8734 cv = append(cv, col) 8735 8736 } 8737 *v = cv 8738 return nil 8739} 8740 8741func awsAwsjson11_deserializeDocumentSocketAddress(v **types.SocketAddress, value interface{}) error { 8742 if v == nil { 8743 return fmt.Errorf("unexpected nil of type %T", v) 8744 } 8745 if value == nil { 8746 return nil 8747 } 8748 8749 shape, ok := value.(map[string]interface{}) 8750 if !ok { 8751 return fmt.Errorf("unexpected JSON type %v", value) 8752 } 8753 8754 var sv *types.SocketAddress 8755 if *v == nil { 8756 sv = &types.SocketAddress{} 8757 } else { 8758 sv = *v 8759 } 8760 8761 for key, value := range shape { 8762 switch key { 8763 case "IpAddress": 8764 if value != nil { 8765 jtv, ok := value.(string) 8766 if !ok { 8767 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8768 } 8769 sv.IpAddress = ptr.String(jtv) 8770 } 8771 8772 case "Port": 8773 if value != nil { 8774 jtv, ok := value.(json.Number) 8775 if !ok { 8776 return fmt.Errorf("expected PortNumber to be json.Number, got %T instead", value) 8777 } 8778 i64, err := jtv.Int64() 8779 if err != nil { 8780 return err 8781 } 8782 sv.Port = ptr.Int32(int32(i64)) 8783 } 8784 8785 default: 8786 _, _ = key, value 8787 8788 } 8789 } 8790 *v = sv 8791 return nil 8792} 8793 8794func awsAwsjson11_deserializeDocumentSocketAddresses(v *[]types.SocketAddress, value interface{}) error { 8795 if v == nil { 8796 return fmt.Errorf("unexpected nil of type %T", v) 8797 } 8798 if value == nil { 8799 return nil 8800 } 8801 8802 shape, ok := value.([]interface{}) 8803 if !ok { 8804 return fmt.Errorf("unexpected JSON type %v", value) 8805 } 8806 8807 var cv []types.SocketAddress 8808 if *v == nil { 8809 cv = []types.SocketAddress{} 8810 } else { 8811 cv = *v 8812 } 8813 8814 for _, value := range shape { 8815 var col types.SocketAddress 8816 destAddr := &col 8817 if err := awsAwsjson11_deserializeDocumentSocketAddress(&destAddr, value); err != nil { 8818 return err 8819 } 8820 col = *destAddr 8821 cv = append(cv, col) 8822 8823 } 8824 *v = cv 8825 return nil 8826} 8827 8828func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 8829 if v == nil { 8830 return fmt.Errorf("unexpected nil of type %T", v) 8831 } 8832 if value == nil { 8833 return nil 8834 } 8835 8836 shape, ok := value.(map[string]interface{}) 8837 if !ok { 8838 return fmt.Errorf("unexpected JSON type %v", value) 8839 } 8840 8841 var sv *types.Tag 8842 if *v == nil { 8843 sv = &types.Tag{} 8844 } else { 8845 sv = *v 8846 } 8847 8848 for key, value := range shape { 8849 switch key { 8850 case "Key": 8851 if value != nil { 8852 jtv, ok := value.(string) 8853 if !ok { 8854 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 8855 } 8856 sv.Key = ptr.String(jtv) 8857 } 8858 8859 case "Value": 8860 if value != nil { 8861 jtv, ok := value.(string) 8862 if !ok { 8863 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 8864 } 8865 sv.Value = ptr.String(jtv) 8866 } 8867 8868 default: 8869 _, _ = key, value 8870 8871 } 8872 } 8873 *v = sv 8874 return nil 8875} 8876 8877func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 8878 if v == nil { 8879 return fmt.Errorf("unexpected nil of type %T", v) 8880 } 8881 if value == nil { 8882 return nil 8883 } 8884 8885 shape, ok := value.([]interface{}) 8886 if !ok { 8887 return fmt.Errorf("unexpected JSON type %v", value) 8888 } 8889 8890 var cv []types.Tag 8891 if *v == nil { 8892 cv = []types.Tag{} 8893 } else { 8894 cv = *v 8895 } 8896 8897 for _, value := range shape { 8898 var col types.Tag 8899 destAddr := &col 8900 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 8901 return err 8902 } 8903 col = *destAddr 8904 cv = append(cv, col) 8905 8906 } 8907 *v = cv 8908 return nil 8909} 8910 8911func awsAwsjson11_deserializeOpDocumentAddCustomRoutingEndpointsOutput(v **AddCustomRoutingEndpointsOutput, value interface{}) error { 8912 if v == nil { 8913 return fmt.Errorf("unexpected nil of type %T", v) 8914 } 8915 if value == nil { 8916 return nil 8917 } 8918 8919 shape, ok := value.(map[string]interface{}) 8920 if !ok { 8921 return fmt.Errorf("unexpected JSON type %v", value) 8922 } 8923 8924 var sv *AddCustomRoutingEndpointsOutput 8925 if *v == nil { 8926 sv = &AddCustomRoutingEndpointsOutput{} 8927 } else { 8928 sv = *v 8929 } 8930 8931 for key, value := range shape { 8932 switch key { 8933 case "EndpointDescriptions": 8934 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointDescriptions(&sv.EndpointDescriptions, value); err != nil { 8935 return err 8936 } 8937 8938 case "EndpointGroupArn": 8939 if value != nil { 8940 jtv, ok := value.(string) 8941 if !ok { 8942 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 8943 } 8944 sv.EndpointGroupArn = ptr.String(jtv) 8945 } 8946 8947 default: 8948 _, _ = key, value 8949 8950 } 8951 } 8952 *v = sv 8953 return nil 8954} 8955 8956func awsAwsjson11_deserializeOpDocumentAdvertiseByoipCidrOutput(v **AdvertiseByoipCidrOutput, value interface{}) error { 8957 if v == nil { 8958 return fmt.Errorf("unexpected nil of type %T", v) 8959 } 8960 if value == nil { 8961 return nil 8962 } 8963 8964 shape, ok := value.(map[string]interface{}) 8965 if !ok { 8966 return fmt.Errorf("unexpected JSON type %v", value) 8967 } 8968 8969 var sv *AdvertiseByoipCidrOutput 8970 if *v == nil { 8971 sv = &AdvertiseByoipCidrOutput{} 8972 } else { 8973 sv = *v 8974 } 8975 8976 for key, value := range shape { 8977 switch key { 8978 case "ByoipCidr": 8979 if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil { 8980 return err 8981 } 8982 8983 default: 8984 _, _ = key, value 8985 8986 } 8987 } 8988 *v = sv 8989 return nil 8990} 8991 8992func awsAwsjson11_deserializeOpDocumentCreateAcceleratorOutput(v **CreateAcceleratorOutput, 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.(map[string]interface{}) 9001 if !ok { 9002 return fmt.Errorf("unexpected JSON type %v", value) 9003 } 9004 9005 var sv *CreateAcceleratorOutput 9006 if *v == nil { 9007 sv = &CreateAcceleratorOutput{} 9008 } else { 9009 sv = *v 9010 } 9011 9012 for key, value := range shape { 9013 switch key { 9014 case "Accelerator": 9015 if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil { 9016 return err 9017 } 9018 9019 default: 9020 _, _ = key, value 9021 9022 } 9023 } 9024 *v = sv 9025 return nil 9026} 9027 9028func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingAcceleratorOutput(v **CreateCustomRoutingAcceleratorOutput, value interface{}) error { 9029 if v == nil { 9030 return fmt.Errorf("unexpected nil of type %T", v) 9031 } 9032 if value == nil { 9033 return nil 9034 } 9035 9036 shape, ok := value.(map[string]interface{}) 9037 if !ok { 9038 return fmt.Errorf("unexpected JSON type %v", value) 9039 } 9040 9041 var sv *CreateCustomRoutingAcceleratorOutput 9042 if *v == nil { 9043 sv = &CreateCustomRoutingAcceleratorOutput{} 9044 } else { 9045 sv = *v 9046 } 9047 9048 for key, value := range shape { 9049 switch key { 9050 case "Accelerator": 9051 if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil { 9052 return err 9053 } 9054 9055 default: 9056 _, _ = key, value 9057 9058 } 9059 } 9060 *v = sv 9061 return nil 9062} 9063 9064func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingEndpointGroupOutput(v **CreateCustomRoutingEndpointGroupOutput, value interface{}) error { 9065 if v == nil { 9066 return fmt.Errorf("unexpected nil of type %T", v) 9067 } 9068 if value == nil { 9069 return nil 9070 } 9071 9072 shape, ok := value.(map[string]interface{}) 9073 if !ok { 9074 return fmt.Errorf("unexpected JSON type %v", value) 9075 } 9076 9077 var sv *CreateCustomRoutingEndpointGroupOutput 9078 if *v == nil { 9079 sv = &CreateCustomRoutingEndpointGroupOutput{} 9080 } else { 9081 sv = *v 9082 } 9083 9084 for key, value := range shape { 9085 switch key { 9086 case "EndpointGroup": 9087 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&sv.EndpointGroup, value); err != nil { 9088 return err 9089 } 9090 9091 default: 9092 _, _ = key, value 9093 9094 } 9095 } 9096 *v = sv 9097 return nil 9098} 9099 9100func awsAwsjson11_deserializeOpDocumentCreateCustomRoutingListenerOutput(v **CreateCustomRoutingListenerOutput, value interface{}) error { 9101 if v == nil { 9102 return fmt.Errorf("unexpected nil of type %T", v) 9103 } 9104 if value == nil { 9105 return nil 9106 } 9107 9108 shape, ok := value.(map[string]interface{}) 9109 if !ok { 9110 return fmt.Errorf("unexpected JSON type %v", value) 9111 } 9112 9113 var sv *CreateCustomRoutingListenerOutput 9114 if *v == nil { 9115 sv = &CreateCustomRoutingListenerOutput{} 9116 } else { 9117 sv = *v 9118 } 9119 9120 for key, value := range shape { 9121 switch key { 9122 case "Listener": 9123 if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil { 9124 return err 9125 } 9126 9127 default: 9128 _, _ = key, value 9129 9130 } 9131 } 9132 *v = sv 9133 return nil 9134} 9135 9136func awsAwsjson11_deserializeOpDocumentCreateEndpointGroupOutput(v **CreateEndpointGroupOutput, value interface{}) error { 9137 if v == nil { 9138 return fmt.Errorf("unexpected nil of type %T", v) 9139 } 9140 if value == nil { 9141 return nil 9142 } 9143 9144 shape, ok := value.(map[string]interface{}) 9145 if !ok { 9146 return fmt.Errorf("unexpected JSON type %v", value) 9147 } 9148 9149 var sv *CreateEndpointGroupOutput 9150 if *v == nil { 9151 sv = &CreateEndpointGroupOutput{} 9152 } else { 9153 sv = *v 9154 } 9155 9156 for key, value := range shape { 9157 switch key { 9158 case "EndpointGroup": 9159 if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil { 9160 return err 9161 } 9162 9163 default: 9164 _, _ = key, value 9165 9166 } 9167 } 9168 *v = sv 9169 return nil 9170} 9171 9172func awsAwsjson11_deserializeOpDocumentCreateListenerOutput(v **CreateListenerOutput, value interface{}) error { 9173 if v == nil { 9174 return fmt.Errorf("unexpected nil of type %T", v) 9175 } 9176 if value == nil { 9177 return nil 9178 } 9179 9180 shape, ok := value.(map[string]interface{}) 9181 if !ok { 9182 return fmt.Errorf("unexpected JSON type %v", value) 9183 } 9184 9185 var sv *CreateListenerOutput 9186 if *v == nil { 9187 sv = &CreateListenerOutput{} 9188 } else { 9189 sv = *v 9190 } 9191 9192 for key, value := range shape { 9193 switch key { 9194 case "Listener": 9195 if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil { 9196 return err 9197 } 9198 9199 default: 9200 _, _ = key, value 9201 9202 } 9203 } 9204 *v = sv 9205 return nil 9206} 9207 9208func awsAwsjson11_deserializeOpDocumentDeprovisionByoipCidrOutput(v **DeprovisionByoipCidrOutput, value interface{}) error { 9209 if v == nil { 9210 return fmt.Errorf("unexpected nil of type %T", v) 9211 } 9212 if value == nil { 9213 return nil 9214 } 9215 9216 shape, ok := value.(map[string]interface{}) 9217 if !ok { 9218 return fmt.Errorf("unexpected JSON type %v", value) 9219 } 9220 9221 var sv *DeprovisionByoipCidrOutput 9222 if *v == nil { 9223 sv = &DeprovisionByoipCidrOutput{} 9224 } else { 9225 sv = *v 9226 } 9227 9228 for key, value := range shape { 9229 switch key { 9230 case "ByoipCidr": 9231 if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil { 9232 return err 9233 } 9234 9235 default: 9236 _, _ = key, value 9237 9238 } 9239 } 9240 *v = sv 9241 return nil 9242} 9243 9244func awsAwsjson11_deserializeOpDocumentDescribeAcceleratorAttributesOutput(v **DescribeAcceleratorAttributesOutput, value interface{}) error { 9245 if v == nil { 9246 return fmt.Errorf("unexpected nil of type %T", v) 9247 } 9248 if value == nil { 9249 return nil 9250 } 9251 9252 shape, ok := value.(map[string]interface{}) 9253 if !ok { 9254 return fmt.Errorf("unexpected JSON type %v", value) 9255 } 9256 9257 var sv *DescribeAcceleratorAttributesOutput 9258 if *v == nil { 9259 sv = &DescribeAcceleratorAttributesOutput{} 9260 } else { 9261 sv = *v 9262 } 9263 9264 for key, value := range shape { 9265 switch key { 9266 case "AcceleratorAttributes": 9267 if err := awsAwsjson11_deserializeDocumentAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil { 9268 return err 9269 } 9270 9271 default: 9272 _, _ = key, value 9273 9274 } 9275 } 9276 *v = sv 9277 return nil 9278} 9279 9280func awsAwsjson11_deserializeOpDocumentDescribeAcceleratorOutput(v **DescribeAcceleratorOutput, value interface{}) error { 9281 if v == nil { 9282 return fmt.Errorf("unexpected nil of type %T", v) 9283 } 9284 if value == nil { 9285 return nil 9286 } 9287 9288 shape, ok := value.(map[string]interface{}) 9289 if !ok { 9290 return fmt.Errorf("unexpected JSON type %v", value) 9291 } 9292 9293 var sv *DescribeAcceleratorOutput 9294 if *v == nil { 9295 sv = &DescribeAcceleratorOutput{} 9296 } else { 9297 sv = *v 9298 } 9299 9300 for key, value := range shape { 9301 switch key { 9302 case "Accelerator": 9303 if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil { 9304 return err 9305 } 9306 9307 default: 9308 _, _ = key, value 9309 9310 } 9311 } 9312 *v = sv 9313 return nil 9314} 9315 9316func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorAttributesOutput(v **DescribeCustomRoutingAcceleratorAttributesOutput, value interface{}) error { 9317 if v == nil { 9318 return fmt.Errorf("unexpected nil of type %T", v) 9319 } 9320 if value == nil { 9321 return nil 9322 } 9323 9324 shape, ok := value.(map[string]interface{}) 9325 if !ok { 9326 return fmt.Errorf("unexpected JSON type %v", value) 9327 } 9328 9329 var sv *DescribeCustomRoutingAcceleratorAttributesOutput 9330 if *v == nil { 9331 sv = &DescribeCustomRoutingAcceleratorAttributesOutput{} 9332 } else { 9333 sv = *v 9334 } 9335 9336 for key, value := range shape { 9337 switch key { 9338 case "AcceleratorAttributes": 9339 if err := awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil { 9340 return err 9341 } 9342 9343 default: 9344 _, _ = key, value 9345 9346 } 9347 } 9348 *v = sv 9349 return nil 9350} 9351 9352func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingAcceleratorOutput(v **DescribeCustomRoutingAcceleratorOutput, value interface{}) error { 9353 if v == nil { 9354 return fmt.Errorf("unexpected nil of type %T", v) 9355 } 9356 if value == nil { 9357 return nil 9358 } 9359 9360 shape, ok := value.(map[string]interface{}) 9361 if !ok { 9362 return fmt.Errorf("unexpected JSON type %v", value) 9363 } 9364 9365 var sv *DescribeCustomRoutingAcceleratorOutput 9366 if *v == nil { 9367 sv = &DescribeCustomRoutingAcceleratorOutput{} 9368 } else { 9369 sv = *v 9370 } 9371 9372 for key, value := range shape { 9373 switch key { 9374 case "Accelerator": 9375 if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil { 9376 return err 9377 } 9378 9379 default: 9380 _, _ = key, value 9381 9382 } 9383 } 9384 *v = sv 9385 return nil 9386} 9387 9388func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingEndpointGroupOutput(v **DescribeCustomRoutingEndpointGroupOutput, value interface{}) error { 9389 if v == nil { 9390 return fmt.Errorf("unexpected nil of type %T", v) 9391 } 9392 if value == nil { 9393 return nil 9394 } 9395 9396 shape, ok := value.(map[string]interface{}) 9397 if !ok { 9398 return fmt.Errorf("unexpected JSON type %v", value) 9399 } 9400 9401 var sv *DescribeCustomRoutingEndpointGroupOutput 9402 if *v == nil { 9403 sv = &DescribeCustomRoutingEndpointGroupOutput{} 9404 } else { 9405 sv = *v 9406 } 9407 9408 for key, value := range shape { 9409 switch key { 9410 case "EndpointGroup": 9411 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroup(&sv.EndpointGroup, value); err != nil { 9412 return err 9413 } 9414 9415 default: 9416 _, _ = key, value 9417 9418 } 9419 } 9420 *v = sv 9421 return nil 9422} 9423 9424func awsAwsjson11_deserializeOpDocumentDescribeCustomRoutingListenerOutput(v **DescribeCustomRoutingListenerOutput, value interface{}) error { 9425 if v == nil { 9426 return fmt.Errorf("unexpected nil of type %T", v) 9427 } 9428 if value == nil { 9429 return nil 9430 } 9431 9432 shape, ok := value.(map[string]interface{}) 9433 if !ok { 9434 return fmt.Errorf("unexpected JSON type %v", value) 9435 } 9436 9437 var sv *DescribeCustomRoutingListenerOutput 9438 if *v == nil { 9439 sv = &DescribeCustomRoutingListenerOutput{} 9440 } else { 9441 sv = *v 9442 } 9443 9444 for key, value := range shape { 9445 switch key { 9446 case "Listener": 9447 if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil { 9448 return err 9449 } 9450 9451 default: 9452 _, _ = key, value 9453 9454 } 9455 } 9456 *v = sv 9457 return nil 9458} 9459 9460func awsAwsjson11_deserializeOpDocumentDescribeEndpointGroupOutput(v **DescribeEndpointGroupOutput, value interface{}) error { 9461 if v == nil { 9462 return fmt.Errorf("unexpected nil of type %T", v) 9463 } 9464 if value == nil { 9465 return nil 9466 } 9467 9468 shape, ok := value.(map[string]interface{}) 9469 if !ok { 9470 return fmt.Errorf("unexpected JSON type %v", value) 9471 } 9472 9473 var sv *DescribeEndpointGroupOutput 9474 if *v == nil { 9475 sv = &DescribeEndpointGroupOutput{} 9476 } else { 9477 sv = *v 9478 } 9479 9480 for key, value := range shape { 9481 switch key { 9482 case "EndpointGroup": 9483 if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil { 9484 return err 9485 } 9486 9487 default: 9488 _, _ = key, value 9489 9490 } 9491 } 9492 *v = sv 9493 return nil 9494} 9495 9496func awsAwsjson11_deserializeOpDocumentDescribeListenerOutput(v **DescribeListenerOutput, value interface{}) error { 9497 if v == nil { 9498 return fmt.Errorf("unexpected nil of type %T", v) 9499 } 9500 if value == nil { 9501 return nil 9502 } 9503 9504 shape, ok := value.(map[string]interface{}) 9505 if !ok { 9506 return fmt.Errorf("unexpected JSON type %v", value) 9507 } 9508 9509 var sv *DescribeListenerOutput 9510 if *v == nil { 9511 sv = &DescribeListenerOutput{} 9512 } else { 9513 sv = *v 9514 } 9515 9516 for key, value := range shape { 9517 switch key { 9518 case "Listener": 9519 if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil { 9520 return err 9521 } 9522 9523 default: 9524 _, _ = key, value 9525 9526 } 9527 } 9528 *v = sv 9529 return nil 9530} 9531 9532func awsAwsjson11_deserializeOpDocumentListAcceleratorsOutput(v **ListAcceleratorsOutput, value interface{}) error { 9533 if v == nil { 9534 return fmt.Errorf("unexpected nil of type %T", v) 9535 } 9536 if value == nil { 9537 return nil 9538 } 9539 9540 shape, ok := value.(map[string]interface{}) 9541 if !ok { 9542 return fmt.Errorf("unexpected JSON type %v", value) 9543 } 9544 9545 var sv *ListAcceleratorsOutput 9546 if *v == nil { 9547 sv = &ListAcceleratorsOutput{} 9548 } else { 9549 sv = *v 9550 } 9551 9552 for key, value := range shape { 9553 switch key { 9554 case "Accelerators": 9555 if err := awsAwsjson11_deserializeDocumentAccelerators(&sv.Accelerators, value); err != nil { 9556 return err 9557 } 9558 9559 case "NextToken": 9560 if value != nil { 9561 jtv, ok := value.(string) 9562 if !ok { 9563 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9564 } 9565 sv.NextToken = ptr.String(jtv) 9566 } 9567 9568 default: 9569 _, _ = key, value 9570 9571 } 9572 } 9573 *v = sv 9574 return nil 9575} 9576 9577func awsAwsjson11_deserializeOpDocumentListByoipCidrsOutput(v **ListByoipCidrsOutput, value interface{}) error { 9578 if v == nil { 9579 return fmt.Errorf("unexpected nil of type %T", v) 9580 } 9581 if value == nil { 9582 return nil 9583 } 9584 9585 shape, ok := value.(map[string]interface{}) 9586 if !ok { 9587 return fmt.Errorf("unexpected JSON type %v", value) 9588 } 9589 9590 var sv *ListByoipCidrsOutput 9591 if *v == nil { 9592 sv = &ListByoipCidrsOutput{} 9593 } else { 9594 sv = *v 9595 } 9596 9597 for key, value := range shape { 9598 switch key { 9599 case "ByoipCidrs": 9600 if err := awsAwsjson11_deserializeDocumentByoipCidrs(&sv.ByoipCidrs, value); err != nil { 9601 return err 9602 } 9603 9604 case "NextToken": 9605 if value != nil { 9606 jtv, ok := value.(string) 9607 if !ok { 9608 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9609 } 9610 sv.NextToken = ptr.String(jtv) 9611 } 9612 9613 default: 9614 _, _ = key, value 9615 9616 } 9617 } 9618 *v = sv 9619 return nil 9620} 9621 9622func awsAwsjson11_deserializeOpDocumentListCustomRoutingAcceleratorsOutput(v **ListCustomRoutingAcceleratorsOutput, value interface{}) error { 9623 if v == nil { 9624 return fmt.Errorf("unexpected nil of type %T", v) 9625 } 9626 if value == nil { 9627 return nil 9628 } 9629 9630 shape, ok := value.(map[string]interface{}) 9631 if !ok { 9632 return fmt.Errorf("unexpected JSON type %v", value) 9633 } 9634 9635 var sv *ListCustomRoutingAcceleratorsOutput 9636 if *v == nil { 9637 sv = &ListCustomRoutingAcceleratorsOutput{} 9638 } else { 9639 sv = *v 9640 } 9641 9642 for key, value := range shape { 9643 switch key { 9644 case "Accelerators": 9645 if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerators(&sv.Accelerators, value); err != nil { 9646 return err 9647 } 9648 9649 case "NextToken": 9650 if value != nil { 9651 jtv, ok := value.(string) 9652 if !ok { 9653 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9654 } 9655 sv.NextToken = ptr.String(jtv) 9656 } 9657 9658 default: 9659 _, _ = key, value 9660 9661 } 9662 } 9663 *v = sv 9664 return nil 9665} 9666 9667func awsAwsjson11_deserializeOpDocumentListCustomRoutingEndpointGroupsOutput(v **ListCustomRoutingEndpointGroupsOutput, value interface{}) error { 9668 if v == nil { 9669 return fmt.Errorf("unexpected nil of type %T", v) 9670 } 9671 if value == nil { 9672 return nil 9673 } 9674 9675 shape, ok := value.(map[string]interface{}) 9676 if !ok { 9677 return fmt.Errorf("unexpected JSON type %v", value) 9678 } 9679 9680 var sv *ListCustomRoutingEndpointGroupsOutput 9681 if *v == nil { 9682 sv = &ListCustomRoutingEndpointGroupsOutput{} 9683 } else { 9684 sv = *v 9685 } 9686 9687 for key, value := range shape { 9688 switch key { 9689 case "EndpointGroups": 9690 if err := awsAwsjson11_deserializeDocumentCustomRoutingEndpointGroups(&sv.EndpointGroups, value); err != nil { 9691 return err 9692 } 9693 9694 case "NextToken": 9695 if value != nil { 9696 jtv, ok := value.(string) 9697 if !ok { 9698 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9699 } 9700 sv.NextToken = ptr.String(jtv) 9701 } 9702 9703 default: 9704 _, _ = key, value 9705 9706 } 9707 } 9708 *v = sv 9709 return nil 9710} 9711 9712func awsAwsjson11_deserializeOpDocumentListCustomRoutingListenersOutput(v **ListCustomRoutingListenersOutput, value interface{}) error { 9713 if v == nil { 9714 return fmt.Errorf("unexpected nil of type %T", v) 9715 } 9716 if value == nil { 9717 return nil 9718 } 9719 9720 shape, ok := value.(map[string]interface{}) 9721 if !ok { 9722 return fmt.Errorf("unexpected JSON type %v", value) 9723 } 9724 9725 var sv *ListCustomRoutingListenersOutput 9726 if *v == nil { 9727 sv = &ListCustomRoutingListenersOutput{} 9728 } else { 9729 sv = *v 9730 } 9731 9732 for key, value := range shape { 9733 switch key { 9734 case "Listeners": 9735 if err := awsAwsjson11_deserializeDocumentCustomRoutingListeners(&sv.Listeners, value); err != nil { 9736 return err 9737 } 9738 9739 case "NextToken": 9740 if value != nil { 9741 jtv, ok := value.(string) 9742 if !ok { 9743 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9744 } 9745 sv.NextToken = ptr.String(jtv) 9746 } 9747 9748 default: 9749 _, _ = key, value 9750 9751 } 9752 } 9753 *v = sv 9754 return nil 9755} 9756 9757func awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsByDestinationOutput(v **ListCustomRoutingPortMappingsByDestinationOutput, value interface{}) error { 9758 if v == nil { 9759 return fmt.Errorf("unexpected nil of type %T", v) 9760 } 9761 if value == nil { 9762 return nil 9763 } 9764 9765 shape, ok := value.(map[string]interface{}) 9766 if !ok { 9767 return fmt.Errorf("unexpected JSON type %v", value) 9768 } 9769 9770 var sv *ListCustomRoutingPortMappingsByDestinationOutput 9771 if *v == nil { 9772 sv = &ListCustomRoutingPortMappingsByDestinationOutput{} 9773 } else { 9774 sv = *v 9775 } 9776 9777 for key, value := range shape { 9778 switch key { 9779 case "DestinationPortMappings": 9780 if err := awsAwsjson11_deserializeDocumentDestinationPortMappings(&sv.DestinationPortMappings, value); err != nil { 9781 return err 9782 } 9783 9784 case "NextToken": 9785 if value != nil { 9786 jtv, ok := value.(string) 9787 if !ok { 9788 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9789 } 9790 sv.NextToken = ptr.String(jtv) 9791 } 9792 9793 default: 9794 _, _ = key, value 9795 9796 } 9797 } 9798 *v = sv 9799 return nil 9800} 9801 9802func awsAwsjson11_deserializeOpDocumentListCustomRoutingPortMappingsOutput(v **ListCustomRoutingPortMappingsOutput, value interface{}) error { 9803 if v == nil { 9804 return fmt.Errorf("unexpected nil of type %T", v) 9805 } 9806 if value == nil { 9807 return nil 9808 } 9809 9810 shape, ok := value.(map[string]interface{}) 9811 if !ok { 9812 return fmt.Errorf("unexpected JSON type %v", value) 9813 } 9814 9815 var sv *ListCustomRoutingPortMappingsOutput 9816 if *v == nil { 9817 sv = &ListCustomRoutingPortMappingsOutput{} 9818 } else { 9819 sv = *v 9820 } 9821 9822 for key, value := range shape { 9823 switch key { 9824 case "NextToken": 9825 if value != nil { 9826 jtv, ok := value.(string) 9827 if !ok { 9828 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9829 } 9830 sv.NextToken = ptr.String(jtv) 9831 } 9832 9833 case "PortMappings": 9834 if err := awsAwsjson11_deserializeDocumentPortMappings(&sv.PortMappings, value); err != nil { 9835 return err 9836 } 9837 9838 default: 9839 _, _ = key, value 9840 9841 } 9842 } 9843 *v = sv 9844 return nil 9845} 9846 9847func awsAwsjson11_deserializeOpDocumentListEndpointGroupsOutput(v **ListEndpointGroupsOutput, value interface{}) error { 9848 if v == nil { 9849 return fmt.Errorf("unexpected nil of type %T", v) 9850 } 9851 if value == nil { 9852 return nil 9853 } 9854 9855 shape, ok := value.(map[string]interface{}) 9856 if !ok { 9857 return fmt.Errorf("unexpected JSON type %v", value) 9858 } 9859 9860 var sv *ListEndpointGroupsOutput 9861 if *v == nil { 9862 sv = &ListEndpointGroupsOutput{} 9863 } else { 9864 sv = *v 9865 } 9866 9867 for key, value := range shape { 9868 switch key { 9869 case "EndpointGroups": 9870 if err := awsAwsjson11_deserializeDocumentEndpointGroups(&sv.EndpointGroups, value); err != nil { 9871 return err 9872 } 9873 9874 case "NextToken": 9875 if value != nil { 9876 jtv, ok := value.(string) 9877 if !ok { 9878 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9879 } 9880 sv.NextToken = ptr.String(jtv) 9881 } 9882 9883 default: 9884 _, _ = key, value 9885 9886 } 9887 } 9888 *v = sv 9889 return nil 9890} 9891 9892func awsAwsjson11_deserializeOpDocumentListListenersOutput(v **ListListenersOutput, value interface{}) error { 9893 if v == nil { 9894 return fmt.Errorf("unexpected nil of type %T", v) 9895 } 9896 if value == nil { 9897 return nil 9898 } 9899 9900 shape, ok := value.(map[string]interface{}) 9901 if !ok { 9902 return fmt.Errorf("unexpected JSON type %v", value) 9903 } 9904 9905 var sv *ListListenersOutput 9906 if *v == nil { 9907 sv = &ListListenersOutput{} 9908 } else { 9909 sv = *v 9910 } 9911 9912 for key, value := range shape { 9913 switch key { 9914 case "Listeners": 9915 if err := awsAwsjson11_deserializeDocumentListeners(&sv.Listeners, value); err != nil { 9916 return err 9917 } 9918 9919 case "NextToken": 9920 if value != nil { 9921 jtv, ok := value.(string) 9922 if !ok { 9923 return fmt.Errorf("expected GenericString to be of type string, got %T instead", value) 9924 } 9925 sv.NextToken = ptr.String(jtv) 9926 } 9927 9928 default: 9929 _, _ = key, value 9930 9931 } 9932 } 9933 *v = sv 9934 return nil 9935} 9936 9937func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 9938 if v == nil { 9939 return fmt.Errorf("unexpected nil of type %T", v) 9940 } 9941 if value == nil { 9942 return nil 9943 } 9944 9945 shape, ok := value.(map[string]interface{}) 9946 if !ok { 9947 return fmt.Errorf("unexpected JSON type %v", value) 9948 } 9949 9950 var sv *ListTagsForResourceOutput 9951 if *v == nil { 9952 sv = &ListTagsForResourceOutput{} 9953 } else { 9954 sv = *v 9955 } 9956 9957 for key, value := range shape { 9958 switch key { 9959 case "Tags": 9960 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 9961 return err 9962 } 9963 9964 default: 9965 _, _ = key, value 9966 9967 } 9968 } 9969 *v = sv 9970 return nil 9971} 9972 9973func awsAwsjson11_deserializeOpDocumentProvisionByoipCidrOutput(v **ProvisionByoipCidrOutput, value interface{}) error { 9974 if v == nil { 9975 return fmt.Errorf("unexpected nil of type %T", v) 9976 } 9977 if value == nil { 9978 return nil 9979 } 9980 9981 shape, ok := value.(map[string]interface{}) 9982 if !ok { 9983 return fmt.Errorf("unexpected JSON type %v", value) 9984 } 9985 9986 var sv *ProvisionByoipCidrOutput 9987 if *v == nil { 9988 sv = &ProvisionByoipCidrOutput{} 9989 } else { 9990 sv = *v 9991 } 9992 9993 for key, value := range shape { 9994 switch key { 9995 case "ByoipCidr": 9996 if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil { 9997 return err 9998 } 9999 10000 default: 10001 _, _ = key, value 10002 10003 } 10004 } 10005 *v = sv 10006 return nil 10007} 10008 10009func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 10010 if v == nil { 10011 return fmt.Errorf("unexpected nil of type %T", v) 10012 } 10013 if value == nil { 10014 return nil 10015 } 10016 10017 shape, ok := value.(map[string]interface{}) 10018 if !ok { 10019 return fmt.Errorf("unexpected JSON type %v", value) 10020 } 10021 10022 var sv *TagResourceOutput 10023 if *v == nil { 10024 sv = &TagResourceOutput{} 10025 } else { 10026 sv = *v 10027 } 10028 10029 for key, value := range shape { 10030 switch key { 10031 default: 10032 _, _ = key, value 10033 10034 } 10035 } 10036 *v = sv 10037 return nil 10038} 10039 10040func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 10041 if v == nil { 10042 return fmt.Errorf("unexpected nil of type %T", v) 10043 } 10044 if value == nil { 10045 return nil 10046 } 10047 10048 shape, ok := value.(map[string]interface{}) 10049 if !ok { 10050 return fmt.Errorf("unexpected JSON type %v", value) 10051 } 10052 10053 var sv *UntagResourceOutput 10054 if *v == nil { 10055 sv = &UntagResourceOutput{} 10056 } else { 10057 sv = *v 10058 } 10059 10060 for key, value := range shape { 10061 switch key { 10062 default: 10063 _, _ = key, value 10064 10065 } 10066 } 10067 *v = sv 10068 return nil 10069} 10070 10071func awsAwsjson11_deserializeOpDocumentUpdateAcceleratorAttributesOutput(v **UpdateAcceleratorAttributesOutput, value interface{}) error { 10072 if v == nil { 10073 return fmt.Errorf("unexpected nil of type %T", v) 10074 } 10075 if value == nil { 10076 return nil 10077 } 10078 10079 shape, ok := value.(map[string]interface{}) 10080 if !ok { 10081 return fmt.Errorf("unexpected JSON type %v", value) 10082 } 10083 10084 var sv *UpdateAcceleratorAttributesOutput 10085 if *v == nil { 10086 sv = &UpdateAcceleratorAttributesOutput{} 10087 } else { 10088 sv = *v 10089 } 10090 10091 for key, value := range shape { 10092 switch key { 10093 case "AcceleratorAttributes": 10094 if err := awsAwsjson11_deserializeDocumentAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil { 10095 return err 10096 } 10097 10098 default: 10099 _, _ = key, value 10100 10101 } 10102 } 10103 *v = sv 10104 return nil 10105} 10106 10107func awsAwsjson11_deserializeOpDocumentUpdateAcceleratorOutput(v **UpdateAcceleratorOutput, value interface{}) error { 10108 if v == nil { 10109 return fmt.Errorf("unexpected nil of type %T", v) 10110 } 10111 if value == nil { 10112 return nil 10113 } 10114 10115 shape, ok := value.(map[string]interface{}) 10116 if !ok { 10117 return fmt.Errorf("unexpected JSON type %v", value) 10118 } 10119 10120 var sv *UpdateAcceleratorOutput 10121 if *v == nil { 10122 sv = &UpdateAcceleratorOutput{} 10123 } else { 10124 sv = *v 10125 } 10126 10127 for key, value := range shape { 10128 switch key { 10129 case "Accelerator": 10130 if err := awsAwsjson11_deserializeDocumentAccelerator(&sv.Accelerator, value); err != nil { 10131 return err 10132 } 10133 10134 default: 10135 _, _ = key, value 10136 10137 } 10138 } 10139 *v = sv 10140 return nil 10141} 10142 10143func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorAttributesOutput(v **UpdateCustomRoutingAcceleratorAttributesOutput, value interface{}) error { 10144 if v == nil { 10145 return fmt.Errorf("unexpected nil of type %T", v) 10146 } 10147 if value == nil { 10148 return nil 10149 } 10150 10151 shape, ok := value.(map[string]interface{}) 10152 if !ok { 10153 return fmt.Errorf("unexpected JSON type %v", value) 10154 } 10155 10156 var sv *UpdateCustomRoutingAcceleratorAttributesOutput 10157 if *v == nil { 10158 sv = &UpdateCustomRoutingAcceleratorAttributesOutput{} 10159 } else { 10160 sv = *v 10161 } 10162 10163 for key, value := range shape { 10164 switch key { 10165 case "AcceleratorAttributes": 10166 if err := awsAwsjson11_deserializeDocumentCustomRoutingAcceleratorAttributes(&sv.AcceleratorAttributes, value); err != nil { 10167 return err 10168 } 10169 10170 default: 10171 _, _ = key, value 10172 10173 } 10174 } 10175 *v = sv 10176 return nil 10177} 10178 10179func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingAcceleratorOutput(v **UpdateCustomRoutingAcceleratorOutput, value interface{}) error { 10180 if v == nil { 10181 return fmt.Errorf("unexpected nil of type %T", v) 10182 } 10183 if value == nil { 10184 return nil 10185 } 10186 10187 shape, ok := value.(map[string]interface{}) 10188 if !ok { 10189 return fmt.Errorf("unexpected JSON type %v", value) 10190 } 10191 10192 var sv *UpdateCustomRoutingAcceleratorOutput 10193 if *v == nil { 10194 sv = &UpdateCustomRoutingAcceleratorOutput{} 10195 } else { 10196 sv = *v 10197 } 10198 10199 for key, value := range shape { 10200 switch key { 10201 case "Accelerator": 10202 if err := awsAwsjson11_deserializeDocumentCustomRoutingAccelerator(&sv.Accelerator, value); err != nil { 10203 return err 10204 } 10205 10206 default: 10207 _, _ = key, value 10208 10209 } 10210 } 10211 *v = sv 10212 return nil 10213} 10214 10215func awsAwsjson11_deserializeOpDocumentUpdateCustomRoutingListenerOutput(v **UpdateCustomRoutingListenerOutput, value interface{}) error { 10216 if v == nil { 10217 return fmt.Errorf("unexpected nil of type %T", v) 10218 } 10219 if value == nil { 10220 return nil 10221 } 10222 10223 shape, ok := value.(map[string]interface{}) 10224 if !ok { 10225 return fmt.Errorf("unexpected JSON type %v", value) 10226 } 10227 10228 var sv *UpdateCustomRoutingListenerOutput 10229 if *v == nil { 10230 sv = &UpdateCustomRoutingListenerOutput{} 10231 } else { 10232 sv = *v 10233 } 10234 10235 for key, value := range shape { 10236 switch key { 10237 case "Listener": 10238 if err := awsAwsjson11_deserializeDocumentCustomRoutingListener(&sv.Listener, value); err != nil { 10239 return err 10240 } 10241 10242 default: 10243 _, _ = key, value 10244 10245 } 10246 } 10247 *v = sv 10248 return nil 10249} 10250 10251func awsAwsjson11_deserializeOpDocumentUpdateEndpointGroupOutput(v **UpdateEndpointGroupOutput, value interface{}) error { 10252 if v == nil { 10253 return fmt.Errorf("unexpected nil of type %T", v) 10254 } 10255 if value == nil { 10256 return nil 10257 } 10258 10259 shape, ok := value.(map[string]interface{}) 10260 if !ok { 10261 return fmt.Errorf("unexpected JSON type %v", value) 10262 } 10263 10264 var sv *UpdateEndpointGroupOutput 10265 if *v == nil { 10266 sv = &UpdateEndpointGroupOutput{} 10267 } else { 10268 sv = *v 10269 } 10270 10271 for key, value := range shape { 10272 switch key { 10273 case "EndpointGroup": 10274 if err := awsAwsjson11_deserializeDocumentEndpointGroup(&sv.EndpointGroup, value); err != nil { 10275 return err 10276 } 10277 10278 default: 10279 _, _ = key, value 10280 10281 } 10282 } 10283 *v = sv 10284 return nil 10285} 10286 10287func awsAwsjson11_deserializeOpDocumentUpdateListenerOutput(v **UpdateListenerOutput, value interface{}) error { 10288 if v == nil { 10289 return fmt.Errorf("unexpected nil of type %T", v) 10290 } 10291 if value == nil { 10292 return nil 10293 } 10294 10295 shape, ok := value.(map[string]interface{}) 10296 if !ok { 10297 return fmt.Errorf("unexpected JSON type %v", value) 10298 } 10299 10300 var sv *UpdateListenerOutput 10301 if *v == nil { 10302 sv = &UpdateListenerOutput{} 10303 } else { 10304 sv = *v 10305 } 10306 10307 for key, value := range shape { 10308 switch key { 10309 case "Listener": 10310 if err := awsAwsjson11_deserializeDocumentListener(&sv.Listener, value); err != nil { 10311 return err 10312 } 10313 10314 default: 10315 _, _ = key, value 10316 10317 } 10318 } 10319 *v = sv 10320 return nil 10321} 10322 10323func awsAwsjson11_deserializeOpDocumentWithdrawByoipCidrOutput(v **WithdrawByoipCidrOutput, value interface{}) error { 10324 if v == nil { 10325 return fmt.Errorf("unexpected nil of type %T", v) 10326 } 10327 if value == nil { 10328 return nil 10329 } 10330 10331 shape, ok := value.(map[string]interface{}) 10332 if !ok { 10333 return fmt.Errorf("unexpected JSON type %v", value) 10334 } 10335 10336 var sv *WithdrawByoipCidrOutput 10337 if *v == nil { 10338 sv = &WithdrawByoipCidrOutput{} 10339 } else { 10340 sv = *v 10341 } 10342 10343 for key, value := range shape { 10344 switch key { 10345 case "ByoipCidr": 10346 if err := awsAwsjson11_deserializeDocumentByoipCidr(&sv.ByoipCidr, value); err != nil { 10347 return err 10348 } 10349 10350 default: 10351 _, _ = key, value 10352 10353 } 10354 } 10355 *v = sv 10356 return nil 10357} 10358