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