1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package snowball 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/snowball/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 awsAwsjson11_deserializeOpCancelCluster struct { 23} 24 25func (*awsAwsjson11_deserializeOpCancelCluster) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCancelCluster) 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, awsAwsjson11_deserializeOpErrorCancelCluster(response, &metadata) 44 } 45 output := &CancelClusterOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentCancelClusterOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorCancelCluster(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("InvalidJobStateException", errorCode): 121 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 122 123 case strings.EqualFold("InvalidResourceException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 125 126 case strings.EqualFold("KMSRequestFailedException", errorCode): 127 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 128 129 default: 130 genericError := &smithy.GenericAPIError{ 131 Code: errorCode, 132 Message: errorMessage, 133 } 134 return genericError 135 136 } 137} 138 139type awsAwsjson11_deserializeOpCancelJob struct { 140} 141 142func (*awsAwsjson11_deserializeOpCancelJob) ID() string { 143 return "OperationDeserializer" 144} 145 146func (m *awsAwsjson11_deserializeOpCancelJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 147 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 148) { 149 out, metadata, err = next.HandleDeserialize(ctx, in) 150 if err != nil { 151 return out, metadata, err 152 } 153 154 response, ok := out.RawResponse.(*smithyhttp.Response) 155 if !ok { 156 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 157 } 158 159 if response.StatusCode < 200 || response.StatusCode >= 300 { 160 return out, metadata, awsAwsjson11_deserializeOpErrorCancelJob(response, &metadata) 161 } 162 output := &CancelJobOutput{} 163 out.Result = output 164 165 var buff [1024]byte 166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 167 168 body := io.TeeReader(response.Body, ringBuffer) 169 decoder := json.NewDecoder(body) 170 decoder.UseNumber() 171 var shape interface{} 172 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 173 var snapshot bytes.Buffer 174 io.Copy(&snapshot, ringBuffer) 175 err = &smithy.DeserializationError{ 176 Err: fmt.Errorf("failed to decode response body, %w", err), 177 Snapshot: snapshot.Bytes(), 178 } 179 return out, metadata, err 180 } 181 182 err = awsAwsjson11_deserializeOpDocumentCancelJobOutput(&output, shape) 183 if err != nil { 184 var snapshot bytes.Buffer 185 io.Copy(&snapshot, ringBuffer) 186 err = &smithy.DeserializationError{ 187 Err: fmt.Errorf("failed to decode response body, %w", err), 188 Snapshot: snapshot.Bytes(), 189 } 190 return out, metadata, err 191 } 192 193 return out, metadata, err 194} 195 196func awsAwsjson11_deserializeOpErrorCancelJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 197 var errorBuffer bytes.Buffer 198 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 199 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 200 } 201 errorBody := bytes.NewReader(errorBuffer.Bytes()) 202 203 errorCode := "UnknownError" 204 errorMessage := errorCode 205 206 code := response.Header.Get("X-Amzn-ErrorType") 207 if len(code) != 0 { 208 errorCode = restjson.SanitizeErrorCode(code) 209 } 210 211 var buff [1024]byte 212 ringBuffer := smithyio.NewRingBuffer(buff[:]) 213 214 body := io.TeeReader(errorBody, ringBuffer) 215 decoder := json.NewDecoder(body) 216 decoder.UseNumber() 217 code, message, err := restjson.GetErrorInfo(decoder) 218 if err != nil { 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 err 226 } 227 228 errorBody.Seek(0, io.SeekStart) 229 if len(code) != 0 { 230 errorCode = restjson.SanitizeErrorCode(code) 231 } 232 if len(message) != 0 { 233 errorMessage = message 234 } 235 236 switch { 237 case strings.EqualFold("InvalidJobStateException", errorCode): 238 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 239 240 case strings.EqualFold("InvalidResourceException", errorCode): 241 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 242 243 case strings.EqualFold("KMSRequestFailedException", errorCode): 244 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 245 246 default: 247 genericError := &smithy.GenericAPIError{ 248 Code: errorCode, 249 Message: errorMessage, 250 } 251 return genericError 252 253 } 254} 255 256type awsAwsjson11_deserializeOpCreateAddress struct { 257} 258 259func (*awsAwsjson11_deserializeOpCreateAddress) ID() string { 260 return "OperationDeserializer" 261} 262 263func (m *awsAwsjson11_deserializeOpCreateAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 264 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 265) { 266 out, metadata, err = next.HandleDeserialize(ctx, in) 267 if err != nil { 268 return out, metadata, err 269 } 270 271 response, ok := out.RawResponse.(*smithyhttp.Response) 272 if !ok { 273 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 274 } 275 276 if response.StatusCode < 200 || response.StatusCode >= 300 { 277 return out, metadata, awsAwsjson11_deserializeOpErrorCreateAddress(response, &metadata) 278 } 279 output := &CreateAddressOutput{} 280 out.Result = output 281 282 var buff [1024]byte 283 ringBuffer := smithyio.NewRingBuffer(buff[:]) 284 285 body := io.TeeReader(response.Body, ringBuffer) 286 decoder := json.NewDecoder(body) 287 decoder.UseNumber() 288 var shape interface{} 289 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 290 var snapshot bytes.Buffer 291 io.Copy(&snapshot, ringBuffer) 292 err = &smithy.DeserializationError{ 293 Err: fmt.Errorf("failed to decode response body, %w", err), 294 Snapshot: snapshot.Bytes(), 295 } 296 return out, metadata, err 297 } 298 299 err = awsAwsjson11_deserializeOpDocumentCreateAddressOutput(&output, shape) 300 if err != nil { 301 var snapshot bytes.Buffer 302 io.Copy(&snapshot, ringBuffer) 303 err = &smithy.DeserializationError{ 304 Err: fmt.Errorf("failed to decode response body, %w", err), 305 Snapshot: snapshot.Bytes(), 306 } 307 return out, metadata, err 308 } 309 310 return out, metadata, err 311} 312 313func awsAwsjson11_deserializeOpErrorCreateAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { 314 var errorBuffer bytes.Buffer 315 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 316 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 317 } 318 errorBody := bytes.NewReader(errorBuffer.Bytes()) 319 320 errorCode := "UnknownError" 321 errorMessage := errorCode 322 323 code := response.Header.Get("X-Amzn-ErrorType") 324 if len(code) != 0 { 325 errorCode = restjson.SanitizeErrorCode(code) 326 } 327 328 var buff [1024]byte 329 ringBuffer := smithyio.NewRingBuffer(buff[:]) 330 331 body := io.TeeReader(errorBody, ringBuffer) 332 decoder := json.NewDecoder(body) 333 decoder.UseNumber() 334 code, message, err := restjson.GetErrorInfo(decoder) 335 if err != nil { 336 var snapshot bytes.Buffer 337 io.Copy(&snapshot, ringBuffer) 338 err = &smithy.DeserializationError{ 339 Err: fmt.Errorf("failed to decode response body, %w", err), 340 Snapshot: snapshot.Bytes(), 341 } 342 return err 343 } 344 345 errorBody.Seek(0, io.SeekStart) 346 if len(code) != 0 { 347 errorCode = restjson.SanitizeErrorCode(code) 348 } 349 if len(message) != 0 { 350 errorMessage = message 351 } 352 353 switch { 354 case strings.EqualFold("InvalidAddressException", errorCode): 355 return awsAwsjson11_deserializeErrorInvalidAddressException(response, errorBody) 356 357 case strings.EqualFold("UnsupportedAddressException", errorCode): 358 return awsAwsjson11_deserializeErrorUnsupportedAddressException(response, errorBody) 359 360 default: 361 genericError := &smithy.GenericAPIError{ 362 Code: errorCode, 363 Message: errorMessage, 364 } 365 return genericError 366 367 } 368} 369 370type awsAwsjson11_deserializeOpCreateCluster struct { 371} 372 373func (*awsAwsjson11_deserializeOpCreateCluster) ID() string { 374 return "OperationDeserializer" 375} 376 377func (m *awsAwsjson11_deserializeOpCreateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 379) { 380 out, metadata, err = next.HandleDeserialize(ctx, in) 381 if err != nil { 382 return out, metadata, err 383 } 384 385 response, ok := out.RawResponse.(*smithyhttp.Response) 386 if !ok { 387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 388 } 389 390 if response.StatusCode < 200 || response.StatusCode >= 300 { 391 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata) 392 } 393 output := &CreateClusterOutput{} 394 out.Result = output 395 396 var buff [1024]byte 397 ringBuffer := smithyio.NewRingBuffer(buff[:]) 398 399 body := io.TeeReader(response.Body, ringBuffer) 400 decoder := json.NewDecoder(body) 401 decoder.UseNumber() 402 var shape interface{} 403 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 404 var snapshot bytes.Buffer 405 io.Copy(&snapshot, ringBuffer) 406 err = &smithy.DeserializationError{ 407 Err: fmt.Errorf("failed to decode response body, %w", err), 408 Snapshot: snapshot.Bytes(), 409 } 410 return out, metadata, err 411 } 412 413 err = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&output, shape) 414 if err != nil { 415 var snapshot bytes.Buffer 416 io.Copy(&snapshot, ringBuffer) 417 err = &smithy.DeserializationError{ 418 Err: fmt.Errorf("failed to decode response body, %w", err), 419 Snapshot: snapshot.Bytes(), 420 } 421 return out, metadata, err 422 } 423 424 return out, metadata, err 425} 426 427func awsAwsjson11_deserializeOpErrorCreateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 428 var errorBuffer bytes.Buffer 429 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 430 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 431 } 432 errorBody := bytes.NewReader(errorBuffer.Bytes()) 433 434 errorCode := "UnknownError" 435 errorMessage := errorCode 436 437 code := response.Header.Get("X-Amzn-ErrorType") 438 if len(code) != 0 { 439 errorCode = restjson.SanitizeErrorCode(code) 440 } 441 442 var buff [1024]byte 443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 444 445 body := io.TeeReader(errorBody, ringBuffer) 446 decoder := json.NewDecoder(body) 447 decoder.UseNumber() 448 code, message, err := restjson.GetErrorInfo(decoder) 449 if err != nil { 450 var snapshot bytes.Buffer 451 io.Copy(&snapshot, ringBuffer) 452 err = &smithy.DeserializationError{ 453 Err: fmt.Errorf("failed to decode response body, %w", err), 454 Snapshot: snapshot.Bytes(), 455 } 456 return err 457 } 458 459 errorBody.Seek(0, io.SeekStart) 460 if len(code) != 0 { 461 errorCode = restjson.SanitizeErrorCode(code) 462 } 463 if len(message) != 0 { 464 errorMessage = message 465 } 466 467 switch { 468 case strings.EqualFold("Ec2RequestFailedException", errorCode): 469 return awsAwsjson11_deserializeErrorEc2RequestFailedException(response, errorBody) 470 471 case strings.EqualFold("InvalidInputCombinationException", errorCode): 472 return awsAwsjson11_deserializeErrorInvalidInputCombinationException(response, errorBody) 473 474 case strings.EqualFold("InvalidResourceException", errorCode): 475 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 476 477 case strings.EqualFold("KMSRequestFailedException", errorCode): 478 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 479 480 default: 481 genericError := &smithy.GenericAPIError{ 482 Code: errorCode, 483 Message: errorMessage, 484 } 485 return genericError 486 487 } 488} 489 490type awsAwsjson11_deserializeOpCreateJob struct { 491} 492 493func (*awsAwsjson11_deserializeOpCreateJob) ID() string { 494 return "OperationDeserializer" 495} 496 497func (m *awsAwsjson11_deserializeOpCreateJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 498 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 499) { 500 out, metadata, err = next.HandleDeserialize(ctx, in) 501 if err != nil { 502 return out, metadata, err 503 } 504 505 response, ok := out.RawResponse.(*smithyhttp.Response) 506 if !ok { 507 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 508 } 509 510 if response.StatusCode < 200 || response.StatusCode >= 300 { 511 return out, metadata, awsAwsjson11_deserializeOpErrorCreateJob(response, &metadata) 512 } 513 output := &CreateJobOutput{} 514 out.Result = output 515 516 var buff [1024]byte 517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 518 519 body := io.TeeReader(response.Body, ringBuffer) 520 decoder := json.NewDecoder(body) 521 decoder.UseNumber() 522 var shape interface{} 523 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 524 var snapshot bytes.Buffer 525 io.Copy(&snapshot, ringBuffer) 526 err = &smithy.DeserializationError{ 527 Err: fmt.Errorf("failed to decode response body, %w", err), 528 Snapshot: snapshot.Bytes(), 529 } 530 return out, metadata, err 531 } 532 533 err = awsAwsjson11_deserializeOpDocumentCreateJobOutput(&output, shape) 534 if err != nil { 535 var snapshot bytes.Buffer 536 io.Copy(&snapshot, ringBuffer) 537 err = &smithy.DeserializationError{ 538 Err: fmt.Errorf("failed to decode response body, %w", err), 539 Snapshot: snapshot.Bytes(), 540 } 541 return out, metadata, err 542 } 543 544 return out, metadata, err 545} 546 547func awsAwsjson11_deserializeOpErrorCreateJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 548 var errorBuffer bytes.Buffer 549 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 550 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 551 } 552 errorBody := bytes.NewReader(errorBuffer.Bytes()) 553 554 errorCode := "UnknownError" 555 errorMessage := errorCode 556 557 code := response.Header.Get("X-Amzn-ErrorType") 558 if len(code) != 0 { 559 errorCode = restjson.SanitizeErrorCode(code) 560 } 561 562 var buff [1024]byte 563 ringBuffer := smithyio.NewRingBuffer(buff[:]) 564 565 body := io.TeeReader(errorBody, ringBuffer) 566 decoder := json.NewDecoder(body) 567 decoder.UseNumber() 568 code, message, err := restjson.GetErrorInfo(decoder) 569 if err != nil { 570 var snapshot bytes.Buffer 571 io.Copy(&snapshot, ringBuffer) 572 err = &smithy.DeserializationError{ 573 Err: fmt.Errorf("failed to decode response body, %w", err), 574 Snapshot: snapshot.Bytes(), 575 } 576 return err 577 } 578 579 errorBody.Seek(0, io.SeekStart) 580 if len(code) != 0 { 581 errorCode = restjson.SanitizeErrorCode(code) 582 } 583 if len(message) != 0 { 584 errorMessage = message 585 } 586 587 switch { 588 case strings.EqualFold("ClusterLimitExceededException", errorCode): 589 return awsAwsjson11_deserializeErrorClusterLimitExceededException(response, errorBody) 590 591 case strings.EqualFold("Ec2RequestFailedException", errorCode): 592 return awsAwsjson11_deserializeErrorEc2RequestFailedException(response, errorBody) 593 594 case strings.EqualFold("InvalidInputCombinationException", errorCode): 595 return awsAwsjson11_deserializeErrorInvalidInputCombinationException(response, errorBody) 596 597 case strings.EqualFold("InvalidResourceException", errorCode): 598 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 599 600 case strings.EqualFold("KMSRequestFailedException", errorCode): 601 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 602 603 default: 604 genericError := &smithy.GenericAPIError{ 605 Code: errorCode, 606 Message: errorMessage, 607 } 608 return genericError 609 610 } 611} 612 613type awsAwsjson11_deserializeOpCreateLongTermPricing struct { 614} 615 616func (*awsAwsjson11_deserializeOpCreateLongTermPricing) ID() string { 617 return "OperationDeserializer" 618} 619 620func (m *awsAwsjson11_deserializeOpCreateLongTermPricing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 621 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 622) { 623 out, metadata, err = next.HandleDeserialize(ctx, in) 624 if err != nil { 625 return out, metadata, err 626 } 627 628 response, ok := out.RawResponse.(*smithyhttp.Response) 629 if !ok { 630 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 631 } 632 633 if response.StatusCode < 200 || response.StatusCode >= 300 { 634 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLongTermPricing(response, &metadata) 635 } 636 output := &CreateLongTermPricingOutput{} 637 out.Result = output 638 639 var buff [1024]byte 640 ringBuffer := smithyio.NewRingBuffer(buff[:]) 641 642 body := io.TeeReader(response.Body, ringBuffer) 643 decoder := json.NewDecoder(body) 644 decoder.UseNumber() 645 var shape interface{} 646 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 647 var snapshot bytes.Buffer 648 io.Copy(&snapshot, ringBuffer) 649 err = &smithy.DeserializationError{ 650 Err: fmt.Errorf("failed to decode response body, %w", err), 651 Snapshot: snapshot.Bytes(), 652 } 653 return out, metadata, err 654 } 655 656 err = awsAwsjson11_deserializeOpDocumentCreateLongTermPricingOutput(&output, shape) 657 if err != nil { 658 var snapshot bytes.Buffer 659 io.Copy(&snapshot, ringBuffer) 660 err = &smithy.DeserializationError{ 661 Err: fmt.Errorf("failed to decode response body, %w", err), 662 Snapshot: snapshot.Bytes(), 663 } 664 return out, metadata, err 665 } 666 667 return out, metadata, err 668} 669 670func awsAwsjson11_deserializeOpErrorCreateLongTermPricing(response *smithyhttp.Response, metadata *middleware.Metadata) error { 671 var errorBuffer bytes.Buffer 672 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 673 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 674 } 675 errorBody := bytes.NewReader(errorBuffer.Bytes()) 676 677 errorCode := "UnknownError" 678 errorMessage := errorCode 679 680 code := response.Header.Get("X-Amzn-ErrorType") 681 if len(code) != 0 { 682 errorCode = restjson.SanitizeErrorCode(code) 683 } 684 685 var buff [1024]byte 686 ringBuffer := smithyio.NewRingBuffer(buff[:]) 687 688 body := io.TeeReader(errorBody, ringBuffer) 689 decoder := json.NewDecoder(body) 690 decoder.UseNumber() 691 code, message, err := restjson.GetErrorInfo(decoder) 692 if err != nil { 693 var snapshot bytes.Buffer 694 io.Copy(&snapshot, ringBuffer) 695 err = &smithy.DeserializationError{ 696 Err: fmt.Errorf("failed to decode response body, %w", err), 697 Snapshot: snapshot.Bytes(), 698 } 699 return err 700 } 701 702 errorBody.Seek(0, io.SeekStart) 703 if len(code) != 0 { 704 errorCode = restjson.SanitizeErrorCode(code) 705 } 706 if len(message) != 0 { 707 errorMessage = message 708 } 709 710 switch { 711 case strings.EqualFold("InvalidResourceException", errorCode): 712 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 713 714 default: 715 genericError := &smithy.GenericAPIError{ 716 Code: errorCode, 717 Message: errorMessage, 718 } 719 return genericError 720 721 } 722} 723 724type awsAwsjson11_deserializeOpCreateReturnShippingLabel struct { 725} 726 727func (*awsAwsjson11_deserializeOpCreateReturnShippingLabel) ID() string { 728 return "OperationDeserializer" 729} 730 731func (m *awsAwsjson11_deserializeOpCreateReturnShippingLabel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 732 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 733) { 734 out, metadata, err = next.HandleDeserialize(ctx, in) 735 if err != nil { 736 return out, metadata, err 737 } 738 739 response, ok := out.RawResponse.(*smithyhttp.Response) 740 if !ok { 741 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 742 } 743 744 if response.StatusCode < 200 || response.StatusCode >= 300 { 745 return out, metadata, awsAwsjson11_deserializeOpErrorCreateReturnShippingLabel(response, &metadata) 746 } 747 output := &CreateReturnShippingLabelOutput{} 748 out.Result = output 749 750 var buff [1024]byte 751 ringBuffer := smithyio.NewRingBuffer(buff[:]) 752 753 body := io.TeeReader(response.Body, ringBuffer) 754 decoder := json.NewDecoder(body) 755 decoder.UseNumber() 756 var shape interface{} 757 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 765 } 766 767 err = awsAwsjson11_deserializeOpDocumentCreateReturnShippingLabelOutput(&output, shape) 768 if err != nil { 769 var snapshot bytes.Buffer 770 io.Copy(&snapshot, ringBuffer) 771 err = &smithy.DeserializationError{ 772 Err: fmt.Errorf("failed to decode response body, %w", err), 773 Snapshot: snapshot.Bytes(), 774 } 775 return out, metadata, err 776 } 777 778 return out, metadata, err 779} 780 781func awsAwsjson11_deserializeOpErrorCreateReturnShippingLabel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 782 var errorBuffer bytes.Buffer 783 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 784 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 785 } 786 errorBody := bytes.NewReader(errorBuffer.Bytes()) 787 788 errorCode := "UnknownError" 789 errorMessage := errorCode 790 791 code := response.Header.Get("X-Amzn-ErrorType") 792 if len(code) != 0 { 793 errorCode = restjson.SanitizeErrorCode(code) 794 } 795 796 var buff [1024]byte 797 ringBuffer := smithyio.NewRingBuffer(buff[:]) 798 799 body := io.TeeReader(errorBody, ringBuffer) 800 decoder := json.NewDecoder(body) 801 decoder.UseNumber() 802 code, message, err := restjson.GetErrorInfo(decoder) 803 if err != nil { 804 var snapshot bytes.Buffer 805 io.Copy(&snapshot, ringBuffer) 806 err = &smithy.DeserializationError{ 807 Err: fmt.Errorf("failed to decode response body, %w", err), 808 Snapshot: snapshot.Bytes(), 809 } 810 return err 811 } 812 813 errorBody.Seek(0, io.SeekStart) 814 if len(code) != 0 { 815 errorCode = restjson.SanitizeErrorCode(code) 816 } 817 if len(message) != 0 { 818 errorMessage = message 819 } 820 821 switch { 822 case strings.EqualFold("ConflictException", errorCode): 823 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 824 825 case strings.EqualFold("InvalidInputCombinationException", errorCode): 826 return awsAwsjson11_deserializeErrorInvalidInputCombinationException(response, errorBody) 827 828 case strings.EqualFold("InvalidJobStateException", errorCode): 829 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 830 831 case strings.EqualFold("InvalidResourceException", errorCode): 832 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 833 834 case strings.EqualFold("ReturnShippingLabelAlreadyExistsException", errorCode): 835 return awsAwsjson11_deserializeErrorReturnShippingLabelAlreadyExistsException(response, errorBody) 836 837 default: 838 genericError := &smithy.GenericAPIError{ 839 Code: errorCode, 840 Message: errorMessage, 841 } 842 return genericError 843 844 } 845} 846 847type awsAwsjson11_deserializeOpDescribeAddress struct { 848} 849 850func (*awsAwsjson11_deserializeOpDescribeAddress) ID() string { 851 return "OperationDeserializer" 852} 853 854func (m *awsAwsjson11_deserializeOpDescribeAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 855 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 856) { 857 out, metadata, err = next.HandleDeserialize(ctx, in) 858 if err != nil { 859 return out, metadata, err 860 } 861 862 response, ok := out.RawResponse.(*smithyhttp.Response) 863 if !ok { 864 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 865 } 866 867 if response.StatusCode < 200 || response.StatusCode >= 300 { 868 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAddress(response, &metadata) 869 } 870 output := &DescribeAddressOutput{} 871 out.Result = output 872 873 var buff [1024]byte 874 ringBuffer := smithyio.NewRingBuffer(buff[:]) 875 876 body := io.TeeReader(response.Body, ringBuffer) 877 decoder := json.NewDecoder(body) 878 decoder.UseNumber() 879 var shape interface{} 880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 881 var snapshot bytes.Buffer 882 io.Copy(&snapshot, ringBuffer) 883 err = &smithy.DeserializationError{ 884 Err: fmt.Errorf("failed to decode response body, %w", err), 885 Snapshot: snapshot.Bytes(), 886 } 887 return out, metadata, err 888 } 889 890 err = awsAwsjson11_deserializeOpDocumentDescribeAddressOutput(&output, shape) 891 if err != nil { 892 var snapshot bytes.Buffer 893 io.Copy(&snapshot, ringBuffer) 894 err = &smithy.DeserializationError{ 895 Err: fmt.Errorf("failed to decode response body, %w", err), 896 Snapshot: snapshot.Bytes(), 897 } 898 return out, metadata, err 899 } 900 901 return out, metadata, err 902} 903 904func awsAwsjson11_deserializeOpErrorDescribeAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error { 905 var errorBuffer bytes.Buffer 906 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 907 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 908 } 909 errorBody := bytes.NewReader(errorBuffer.Bytes()) 910 911 errorCode := "UnknownError" 912 errorMessage := errorCode 913 914 code := response.Header.Get("X-Amzn-ErrorType") 915 if len(code) != 0 { 916 errorCode = restjson.SanitizeErrorCode(code) 917 } 918 919 var buff [1024]byte 920 ringBuffer := smithyio.NewRingBuffer(buff[:]) 921 922 body := io.TeeReader(errorBody, ringBuffer) 923 decoder := json.NewDecoder(body) 924 decoder.UseNumber() 925 code, message, err := restjson.GetErrorInfo(decoder) 926 if err != nil { 927 var snapshot bytes.Buffer 928 io.Copy(&snapshot, ringBuffer) 929 err = &smithy.DeserializationError{ 930 Err: fmt.Errorf("failed to decode response body, %w", err), 931 Snapshot: snapshot.Bytes(), 932 } 933 return err 934 } 935 936 errorBody.Seek(0, io.SeekStart) 937 if len(code) != 0 { 938 errorCode = restjson.SanitizeErrorCode(code) 939 } 940 if len(message) != 0 { 941 errorMessage = message 942 } 943 944 switch { 945 case strings.EqualFold("InvalidResourceException", errorCode): 946 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 947 948 default: 949 genericError := &smithy.GenericAPIError{ 950 Code: errorCode, 951 Message: errorMessage, 952 } 953 return genericError 954 955 } 956} 957 958type awsAwsjson11_deserializeOpDescribeAddresses struct { 959} 960 961func (*awsAwsjson11_deserializeOpDescribeAddresses) ID() string { 962 return "OperationDeserializer" 963} 964 965func (m *awsAwsjson11_deserializeOpDescribeAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 966 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 967) { 968 out, metadata, err = next.HandleDeserialize(ctx, in) 969 if err != nil { 970 return out, metadata, err 971 } 972 973 response, ok := out.RawResponse.(*smithyhttp.Response) 974 if !ok { 975 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 976 } 977 978 if response.StatusCode < 200 || response.StatusCode >= 300 { 979 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAddresses(response, &metadata) 980 } 981 output := &DescribeAddressesOutput{} 982 out.Result = output 983 984 var buff [1024]byte 985 ringBuffer := smithyio.NewRingBuffer(buff[:]) 986 987 body := io.TeeReader(response.Body, ringBuffer) 988 decoder := json.NewDecoder(body) 989 decoder.UseNumber() 990 var shape interface{} 991 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 992 var snapshot bytes.Buffer 993 io.Copy(&snapshot, ringBuffer) 994 err = &smithy.DeserializationError{ 995 Err: fmt.Errorf("failed to decode response body, %w", err), 996 Snapshot: snapshot.Bytes(), 997 } 998 return out, metadata, err 999 } 1000 1001 err = awsAwsjson11_deserializeOpDocumentDescribeAddressesOutput(&output, shape) 1002 if err != nil { 1003 var snapshot bytes.Buffer 1004 io.Copy(&snapshot, ringBuffer) 1005 err = &smithy.DeserializationError{ 1006 Err: fmt.Errorf("failed to decode response body, %w", err), 1007 Snapshot: snapshot.Bytes(), 1008 } 1009 return out, metadata, err 1010 } 1011 1012 return out, metadata, err 1013} 1014 1015func awsAwsjson11_deserializeOpErrorDescribeAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1016 var errorBuffer bytes.Buffer 1017 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1018 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1019 } 1020 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1021 1022 errorCode := "UnknownError" 1023 errorMessage := errorCode 1024 1025 code := response.Header.Get("X-Amzn-ErrorType") 1026 if len(code) != 0 { 1027 errorCode = restjson.SanitizeErrorCode(code) 1028 } 1029 1030 var buff [1024]byte 1031 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1032 1033 body := io.TeeReader(errorBody, ringBuffer) 1034 decoder := json.NewDecoder(body) 1035 decoder.UseNumber() 1036 code, message, err := restjson.GetErrorInfo(decoder) 1037 if err != nil { 1038 var snapshot bytes.Buffer 1039 io.Copy(&snapshot, ringBuffer) 1040 err = &smithy.DeserializationError{ 1041 Err: fmt.Errorf("failed to decode response body, %w", err), 1042 Snapshot: snapshot.Bytes(), 1043 } 1044 return err 1045 } 1046 1047 errorBody.Seek(0, io.SeekStart) 1048 if len(code) != 0 { 1049 errorCode = restjson.SanitizeErrorCode(code) 1050 } 1051 if len(message) != 0 { 1052 errorMessage = message 1053 } 1054 1055 switch { 1056 case strings.EqualFold("InvalidNextTokenException", errorCode): 1057 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1058 1059 case strings.EqualFold("InvalidResourceException", errorCode): 1060 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1061 1062 default: 1063 genericError := &smithy.GenericAPIError{ 1064 Code: errorCode, 1065 Message: errorMessage, 1066 } 1067 return genericError 1068 1069 } 1070} 1071 1072type awsAwsjson11_deserializeOpDescribeCluster struct { 1073} 1074 1075func (*awsAwsjson11_deserializeOpDescribeCluster) ID() string { 1076 return "OperationDeserializer" 1077} 1078 1079func (m *awsAwsjson11_deserializeOpDescribeCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1080 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1081) { 1082 out, metadata, err = next.HandleDeserialize(ctx, in) 1083 if err != nil { 1084 return out, metadata, err 1085 } 1086 1087 response, ok := out.RawResponse.(*smithyhttp.Response) 1088 if !ok { 1089 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1090 } 1091 1092 if response.StatusCode < 200 || response.StatusCode >= 300 { 1093 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCluster(response, &metadata) 1094 } 1095 output := &DescribeClusterOutput{} 1096 out.Result = output 1097 1098 var buff [1024]byte 1099 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1100 1101 body := io.TeeReader(response.Body, ringBuffer) 1102 decoder := json.NewDecoder(body) 1103 decoder.UseNumber() 1104 var shape interface{} 1105 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1106 var snapshot bytes.Buffer 1107 io.Copy(&snapshot, ringBuffer) 1108 err = &smithy.DeserializationError{ 1109 Err: fmt.Errorf("failed to decode response body, %w", err), 1110 Snapshot: snapshot.Bytes(), 1111 } 1112 return out, metadata, err 1113 } 1114 1115 err = awsAwsjson11_deserializeOpDocumentDescribeClusterOutput(&output, shape) 1116 if err != nil { 1117 var snapshot bytes.Buffer 1118 io.Copy(&snapshot, ringBuffer) 1119 err = &smithy.DeserializationError{ 1120 Err: fmt.Errorf("failed to decode response body, %w", err), 1121 Snapshot: snapshot.Bytes(), 1122 } 1123 return out, metadata, err 1124 } 1125 1126 return out, metadata, err 1127} 1128 1129func awsAwsjson11_deserializeOpErrorDescribeCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1130 var errorBuffer bytes.Buffer 1131 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1132 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1133 } 1134 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1135 1136 errorCode := "UnknownError" 1137 errorMessage := errorCode 1138 1139 code := response.Header.Get("X-Amzn-ErrorType") 1140 if len(code) != 0 { 1141 errorCode = restjson.SanitizeErrorCode(code) 1142 } 1143 1144 var buff [1024]byte 1145 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1146 1147 body := io.TeeReader(errorBody, ringBuffer) 1148 decoder := json.NewDecoder(body) 1149 decoder.UseNumber() 1150 code, message, err := restjson.GetErrorInfo(decoder) 1151 if err != nil { 1152 var snapshot bytes.Buffer 1153 io.Copy(&snapshot, ringBuffer) 1154 err = &smithy.DeserializationError{ 1155 Err: fmt.Errorf("failed to decode response body, %w", err), 1156 Snapshot: snapshot.Bytes(), 1157 } 1158 return err 1159 } 1160 1161 errorBody.Seek(0, io.SeekStart) 1162 if len(code) != 0 { 1163 errorCode = restjson.SanitizeErrorCode(code) 1164 } 1165 if len(message) != 0 { 1166 errorMessage = message 1167 } 1168 1169 switch { 1170 case strings.EqualFold("InvalidResourceException", errorCode): 1171 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1172 1173 default: 1174 genericError := &smithy.GenericAPIError{ 1175 Code: errorCode, 1176 Message: errorMessage, 1177 } 1178 return genericError 1179 1180 } 1181} 1182 1183type awsAwsjson11_deserializeOpDescribeJob struct { 1184} 1185 1186func (*awsAwsjson11_deserializeOpDescribeJob) ID() string { 1187 return "OperationDeserializer" 1188} 1189 1190func (m *awsAwsjson11_deserializeOpDescribeJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1191 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1192) { 1193 out, metadata, err = next.HandleDeserialize(ctx, in) 1194 if err != nil { 1195 return out, metadata, err 1196 } 1197 1198 response, ok := out.RawResponse.(*smithyhttp.Response) 1199 if !ok { 1200 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1201 } 1202 1203 if response.StatusCode < 200 || response.StatusCode >= 300 { 1204 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeJob(response, &metadata) 1205 } 1206 output := &DescribeJobOutput{} 1207 out.Result = output 1208 1209 var buff [1024]byte 1210 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1211 1212 body := io.TeeReader(response.Body, ringBuffer) 1213 decoder := json.NewDecoder(body) 1214 decoder.UseNumber() 1215 var shape interface{} 1216 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1217 var snapshot bytes.Buffer 1218 io.Copy(&snapshot, ringBuffer) 1219 err = &smithy.DeserializationError{ 1220 Err: fmt.Errorf("failed to decode response body, %w", err), 1221 Snapshot: snapshot.Bytes(), 1222 } 1223 return out, metadata, err 1224 } 1225 1226 err = awsAwsjson11_deserializeOpDocumentDescribeJobOutput(&output, shape) 1227 if err != nil { 1228 var snapshot bytes.Buffer 1229 io.Copy(&snapshot, ringBuffer) 1230 err = &smithy.DeserializationError{ 1231 Err: fmt.Errorf("failed to decode response body, %w", err), 1232 Snapshot: snapshot.Bytes(), 1233 } 1234 return out, metadata, err 1235 } 1236 1237 return out, metadata, err 1238} 1239 1240func awsAwsjson11_deserializeOpErrorDescribeJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1241 var errorBuffer bytes.Buffer 1242 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1243 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1244 } 1245 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1246 1247 errorCode := "UnknownError" 1248 errorMessage := errorCode 1249 1250 code := response.Header.Get("X-Amzn-ErrorType") 1251 if len(code) != 0 { 1252 errorCode = restjson.SanitizeErrorCode(code) 1253 } 1254 1255 var buff [1024]byte 1256 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1257 1258 body := io.TeeReader(errorBody, ringBuffer) 1259 decoder := json.NewDecoder(body) 1260 decoder.UseNumber() 1261 code, message, err := restjson.GetErrorInfo(decoder) 1262 if err != nil { 1263 var snapshot bytes.Buffer 1264 io.Copy(&snapshot, ringBuffer) 1265 err = &smithy.DeserializationError{ 1266 Err: fmt.Errorf("failed to decode response body, %w", err), 1267 Snapshot: snapshot.Bytes(), 1268 } 1269 return err 1270 } 1271 1272 errorBody.Seek(0, io.SeekStart) 1273 if len(code) != 0 { 1274 errorCode = restjson.SanitizeErrorCode(code) 1275 } 1276 if len(message) != 0 { 1277 errorMessage = message 1278 } 1279 1280 switch { 1281 case strings.EqualFold("InvalidResourceException", errorCode): 1282 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1283 1284 default: 1285 genericError := &smithy.GenericAPIError{ 1286 Code: errorCode, 1287 Message: errorMessage, 1288 } 1289 return genericError 1290 1291 } 1292} 1293 1294type awsAwsjson11_deserializeOpDescribeReturnShippingLabel struct { 1295} 1296 1297func (*awsAwsjson11_deserializeOpDescribeReturnShippingLabel) ID() string { 1298 return "OperationDeserializer" 1299} 1300 1301func (m *awsAwsjson11_deserializeOpDescribeReturnShippingLabel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1302 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1303) { 1304 out, metadata, err = next.HandleDeserialize(ctx, in) 1305 if err != nil { 1306 return out, metadata, err 1307 } 1308 1309 response, ok := out.RawResponse.(*smithyhttp.Response) 1310 if !ok { 1311 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1312 } 1313 1314 if response.StatusCode < 200 || response.StatusCode >= 300 { 1315 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReturnShippingLabel(response, &metadata) 1316 } 1317 output := &DescribeReturnShippingLabelOutput{} 1318 out.Result = output 1319 1320 var buff [1024]byte 1321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1322 1323 body := io.TeeReader(response.Body, ringBuffer) 1324 decoder := json.NewDecoder(body) 1325 decoder.UseNumber() 1326 var shape interface{} 1327 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1328 var snapshot bytes.Buffer 1329 io.Copy(&snapshot, ringBuffer) 1330 err = &smithy.DeserializationError{ 1331 Err: fmt.Errorf("failed to decode response body, %w", err), 1332 Snapshot: snapshot.Bytes(), 1333 } 1334 return out, metadata, err 1335 } 1336 1337 err = awsAwsjson11_deserializeOpDocumentDescribeReturnShippingLabelOutput(&output, shape) 1338 if err != nil { 1339 var snapshot bytes.Buffer 1340 io.Copy(&snapshot, ringBuffer) 1341 err = &smithy.DeserializationError{ 1342 Err: fmt.Errorf("failed to decode response body, %w", err), 1343 Snapshot: snapshot.Bytes(), 1344 } 1345 return out, metadata, err 1346 } 1347 1348 return out, metadata, err 1349} 1350 1351func awsAwsjson11_deserializeOpErrorDescribeReturnShippingLabel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1352 var errorBuffer bytes.Buffer 1353 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1354 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1355 } 1356 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1357 1358 errorCode := "UnknownError" 1359 errorMessage := errorCode 1360 1361 code := response.Header.Get("X-Amzn-ErrorType") 1362 if len(code) != 0 { 1363 errorCode = restjson.SanitizeErrorCode(code) 1364 } 1365 1366 var buff [1024]byte 1367 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1368 1369 body := io.TeeReader(errorBody, ringBuffer) 1370 decoder := json.NewDecoder(body) 1371 decoder.UseNumber() 1372 code, message, err := restjson.GetErrorInfo(decoder) 1373 if err != nil { 1374 var snapshot bytes.Buffer 1375 io.Copy(&snapshot, ringBuffer) 1376 err = &smithy.DeserializationError{ 1377 Err: fmt.Errorf("failed to decode response body, %w", err), 1378 Snapshot: snapshot.Bytes(), 1379 } 1380 return err 1381 } 1382 1383 errorBody.Seek(0, io.SeekStart) 1384 if len(code) != 0 { 1385 errorCode = restjson.SanitizeErrorCode(code) 1386 } 1387 if len(message) != 0 { 1388 errorMessage = message 1389 } 1390 1391 switch { 1392 case strings.EqualFold("ConflictException", errorCode): 1393 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 1394 1395 case strings.EqualFold("InvalidJobStateException", errorCode): 1396 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 1397 1398 case strings.EqualFold("InvalidResourceException", errorCode): 1399 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1400 1401 default: 1402 genericError := &smithy.GenericAPIError{ 1403 Code: errorCode, 1404 Message: errorMessage, 1405 } 1406 return genericError 1407 1408 } 1409} 1410 1411type awsAwsjson11_deserializeOpGetJobManifest struct { 1412} 1413 1414func (*awsAwsjson11_deserializeOpGetJobManifest) ID() string { 1415 return "OperationDeserializer" 1416} 1417 1418func (m *awsAwsjson11_deserializeOpGetJobManifest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1419 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1420) { 1421 out, metadata, err = next.HandleDeserialize(ctx, in) 1422 if err != nil { 1423 return out, metadata, err 1424 } 1425 1426 response, ok := out.RawResponse.(*smithyhttp.Response) 1427 if !ok { 1428 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1429 } 1430 1431 if response.StatusCode < 200 || response.StatusCode >= 300 { 1432 return out, metadata, awsAwsjson11_deserializeOpErrorGetJobManifest(response, &metadata) 1433 } 1434 output := &GetJobManifestOutput{} 1435 out.Result = output 1436 1437 var buff [1024]byte 1438 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1439 1440 body := io.TeeReader(response.Body, ringBuffer) 1441 decoder := json.NewDecoder(body) 1442 decoder.UseNumber() 1443 var shape interface{} 1444 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1445 var snapshot bytes.Buffer 1446 io.Copy(&snapshot, ringBuffer) 1447 err = &smithy.DeserializationError{ 1448 Err: fmt.Errorf("failed to decode response body, %w", err), 1449 Snapshot: snapshot.Bytes(), 1450 } 1451 return out, metadata, err 1452 } 1453 1454 err = awsAwsjson11_deserializeOpDocumentGetJobManifestOutput(&output, shape) 1455 if err != nil { 1456 var snapshot bytes.Buffer 1457 io.Copy(&snapshot, ringBuffer) 1458 err = &smithy.DeserializationError{ 1459 Err: fmt.Errorf("failed to decode response body, %w", err), 1460 Snapshot: snapshot.Bytes(), 1461 } 1462 return out, metadata, err 1463 } 1464 1465 return out, metadata, err 1466} 1467 1468func awsAwsjson11_deserializeOpErrorGetJobManifest(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1469 var errorBuffer bytes.Buffer 1470 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1471 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1472 } 1473 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1474 1475 errorCode := "UnknownError" 1476 errorMessage := errorCode 1477 1478 code := response.Header.Get("X-Amzn-ErrorType") 1479 if len(code) != 0 { 1480 errorCode = restjson.SanitizeErrorCode(code) 1481 } 1482 1483 var buff [1024]byte 1484 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1485 1486 body := io.TeeReader(errorBody, ringBuffer) 1487 decoder := json.NewDecoder(body) 1488 decoder.UseNumber() 1489 code, message, err := restjson.GetErrorInfo(decoder) 1490 if err != nil { 1491 var snapshot bytes.Buffer 1492 io.Copy(&snapshot, ringBuffer) 1493 err = &smithy.DeserializationError{ 1494 Err: fmt.Errorf("failed to decode response body, %w", err), 1495 Snapshot: snapshot.Bytes(), 1496 } 1497 return err 1498 } 1499 1500 errorBody.Seek(0, io.SeekStart) 1501 if len(code) != 0 { 1502 errorCode = restjson.SanitizeErrorCode(code) 1503 } 1504 if len(message) != 0 { 1505 errorMessage = message 1506 } 1507 1508 switch { 1509 case strings.EqualFold("InvalidJobStateException", errorCode): 1510 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 1511 1512 case strings.EqualFold("InvalidResourceException", errorCode): 1513 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1514 1515 default: 1516 genericError := &smithy.GenericAPIError{ 1517 Code: errorCode, 1518 Message: errorMessage, 1519 } 1520 return genericError 1521 1522 } 1523} 1524 1525type awsAwsjson11_deserializeOpGetJobUnlockCode struct { 1526} 1527 1528func (*awsAwsjson11_deserializeOpGetJobUnlockCode) ID() string { 1529 return "OperationDeserializer" 1530} 1531 1532func (m *awsAwsjson11_deserializeOpGetJobUnlockCode) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1533 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1534) { 1535 out, metadata, err = next.HandleDeserialize(ctx, in) 1536 if err != nil { 1537 return out, metadata, err 1538 } 1539 1540 response, ok := out.RawResponse.(*smithyhttp.Response) 1541 if !ok { 1542 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1543 } 1544 1545 if response.StatusCode < 200 || response.StatusCode >= 300 { 1546 return out, metadata, awsAwsjson11_deserializeOpErrorGetJobUnlockCode(response, &metadata) 1547 } 1548 output := &GetJobUnlockCodeOutput{} 1549 out.Result = output 1550 1551 var buff [1024]byte 1552 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1553 1554 body := io.TeeReader(response.Body, ringBuffer) 1555 decoder := json.NewDecoder(body) 1556 decoder.UseNumber() 1557 var shape interface{} 1558 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 1566 } 1567 1568 err = awsAwsjson11_deserializeOpDocumentGetJobUnlockCodeOutput(&output, shape) 1569 if err != nil { 1570 var snapshot bytes.Buffer 1571 io.Copy(&snapshot, ringBuffer) 1572 err = &smithy.DeserializationError{ 1573 Err: fmt.Errorf("failed to decode response body, %w", err), 1574 Snapshot: snapshot.Bytes(), 1575 } 1576 return out, metadata, err 1577 } 1578 1579 return out, metadata, err 1580} 1581 1582func awsAwsjson11_deserializeOpErrorGetJobUnlockCode(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1583 var errorBuffer bytes.Buffer 1584 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1585 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1586 } 1587 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1588 1589 errorCode := "UnknownError" 1590 errorMessage := errorCode 1591 1592 code := response.Header.Get("X-Amzn-ErrorType") 1593 if len(code) != 0 { 1594 errorCode = restjson.SanitizeErrorCode(code) 1595 } 1596 1597 var buff [1024]byte 1598 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1599 1600 body := io.TeeReader(errorBody, ringBuffer) 1601 decoder := json.NewDecoder(body) 1602 decoder.UseNumber() 1603 code, message, err := restjson.GetErrorInfo(decoder) 1604 if err != nil { 1605 var snapshot bytes.Buffer 1606 io.Copy(&snapshot, ringBuffer) 1607 err = &smithy.DeserializationError{ 1608 Err: fmt.Errorf("failed to decode response body, %w", err), 1609 Snapshot: snapshot.Bytes(), 1610 } 1611 return err 1612 } 1613 1614 errorBody.Seek(0, io.SeekStart) 1615 if len(code) != 0 { 1616 errorCode = restjson.SanitizeErrorCode(code) 1617 } 1618 if len(message) != 0 { 1619 errorMessage = message 1620 } 1621 1622 switch { 1623 case strings.EqualFold("InvalidJobStateException", errorCode): 1624 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 1625 1626 case strings.EqualFold("InvalidResourceException", errorCode): 1627 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1628 1629 default: 1630 genericError := &smithy.GenericAPIError{ 1631 Code: errorCode, 1632 Message: errorMessage, 1633 } 1634 return genericError 1635 1636 } 1637} 1638 1639type awsAwsjson11_deserializeOpGetSnowballUsage struct { 1640} 1641 1642func (*awsAwsjson11_deserializeOpGetSnowballUsage) ID() string { 1643 return "OperationDeserializer" 1644} 1645 1646func (m *awsAwsjson11_deserializeOpGetSnowballUsage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1647 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1648) { 1649 out, metadata, err = next.HandleDeserialize(ctx, in) 1650 if err != nil { 1651 return out, metadata, err 1652 } 1653 1654 response, ok := out.RawResponse.(*smithyhttp.Response) 1655 if !ok { 1656 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1657 } 1658 1659 if response.StatusCode < 200 || response.StatusCode >= 300 { 1660 return out, metadata, awsAwsjson11_deserializeOpErrorGetSnowballUsage(response, &metadata) 1661 } 1662 output := &GetSnowballUsageOutput{} 1663 out.Result = output 1664 1665 var buff [1024]byte 1666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1667 1668 body := io.TeeReader(response.Body, ringBuffer) 1669 decoder := json.NewDecoder(body) 1670 decoder.UseNumber() 1671 var shape interface{} 1672 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1673 var snapshot bytes.Buffer 1674 io.Copy(&snapshot, ringBuffer) 1675 err = &smithy.DeserializationError{ 1676 Err: fmt.Errorf("failed to decode response body, %w", err), 1677 Snapshot: snapshot.Bytes(), 1678 } 1679 return out, metadata, err 1680 } 1681 1682 err = awsAwsjson11_deserializeOpDocumentGetSnowballUsageOutput(&output, shape) 1683 if err != nil { 1684 var snapshot bytes.Buffer 1685 io.Copy(&snapshot, ringBuffer) 1686 err = &smithy.DeserializationError{ 1687 Err: fmt.Errorf("failed to decode response body, %w", err), 1688 Snapshot: snapshot.Bytes(), 1689 } 1690 return out, metadata, err 1691 } 1692 1693 return out, metadata, err 1694} 1695 1696func awsAwsjson11_deserializeOpErrorGetSnowballUsage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1697 var errorBuffer bytes.Buffer 1698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1700 } 1701 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1702 1703 errorCode := "UnknownError" 1704 errorMessage := errorCode 1705 1706 code := response.Header.Get("X-Amzn-ErrorType") 1707 if len(code) != 0 { 1708 errorCode = restjson.SanitizeErrorCode(code) 1709 } 1710 1711 var buff [1024]byte 1712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1713 1714 body := io.TeeReader(errorBody, ringBuffer) 1715 decoder := json.NewDecoder(body) 1716 decoder.UseNumber() 1717 code, message, err := restjson.GetErrorInfo(decoder) 1718 if err != nil { 1719 var snapshot bytes.Buffer 1720 io.Copy(&snapshot, ringBuffer) 1721 err = &smithy.DeserializationError{ 1722 Err: fmt.Errorf("failed to decode response body, %w", err), 1723 Snapshot: snapshot.Bytes(), 1724 } 1725 return err 1726 } 1727 1728 errorBody.Seek(0, io.SeekStart) 1729 if len(code) != 0 { 1730 errorCode = restjson.SanitizeErrorCode(code) 1731 } 1732 if len(message) != 0 { 1733 errorMessage = message 1734 } 1735 1736 switch { 1737 default: 1738 genericError := &smithy.GenericAPIError{ 1739 Code: errorCode, 1740 Message: errorMessage, 1741 } 1742 return genericError 1743 1744 } 1745} 1746 1747type awsAwsjson11_deserializeOpGetSoftwareUpdates struct { 1748} 1749 1750func (*awsAwsjson11_deserializeOpGetSoftwareUpdates) ID() string { 1751 return "OperationDeserializer" 1752} 1753 1754func (m *awsAwsjson11_deserializeOpGetSoftwareUpdates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1755 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1756) { 1757 out, metadata, err = next.HandleDeserialize(ctx, in) 1758 if err != nil { 1759 return out, metadata, err 1760 } 1761 1762 response, ok := out.RawResponse.(*smithyhttp.Response) 1763 if !ok { 1764 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1765 } 1766 1767 if response.StatusCode < 200 || response.StatusCode >= 300 { 1768 return out, metadata, awsAwsjson11_deserializeOpErrorGetSoftwareUpdates(response, &metadata) 1769 } 1770 output := &GetSoftwareUpdatesOutput{} 1771 out.Result = output 1772 1773 var buff [1024]byte 1774 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1775 1776 body := io.TeeReader(response.Body, ringBuffer) 1777 decoder := json.NewDecoder(body) 1778 decoder.UseNumber() 1779 var shape interface{} 1780 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1781 var snapshot bytes.Buffer 1782 io.Copy(&snapshot, ringBuffer) 1783 err = &smithy.DeserializationError{ 1784 Err: fmt.Errorf("failed to decode response body, %w", err), 1785 Snapshot: snapshot.Bytes(), 1786 } 1787 return out, metadata, err 1788 } 1789 1790 err = awsAwsjson11_deserializeOpDocumentGetSoftwareUpdatesOutput(&output, shape) 1791 if err != nil { 1792 var snapshot bytes.Buffer 1793 io.Copy(&snapshot, ringBuffer) 1794 err = &smithy.DeserializationError{ 1795 Err: fmt.Errorf("failed to decode response body, %w", err), 1796 Snapshot: snapshot.Bytes(), 1797 } 1798 return out, metadata, err 1799 } 1800 1801 return out, metadata, err 1802} 1803 1804func awsAwsjson11_deserializeOpErrorGetSoftwareUpdates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1805 var errorBuffer bytes.Buffer 1806 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1807 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1808 } 1809 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1810 1811 errorCode := "UnknownError" 1812 errorMessage := errorCode 1813 1814 code := response.Header.Get("X-Amzn-ErrorType") 1815 if len(code) != 0 { 1816 errorCode = restjson.SanitizeErrorCode(code) 1817 } 1818 1819 var buff [1024]byte 1820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1821 1822 body := io.TeeReader(errorBody, ringBuffer) 1823 decoder := json.NewDecoder(body) 1824 decoder.UseNumber() 1825 code, message, err := restjson.GetErrorInfo(decoder) 1826 if err != nil { 1827 var snapshot bytes.Buffer 1828 io.Copy(&snapshot, ringBuffer) 1829 err = &smithy.DeserializationError{ 1830 Err: fmt.Errorf("failed to decode response body, %w", err), 1831 Snapshot: snapshot.Bytes(), 1832 } 1833 return err 1834 } 1835 1836 errorBody.Seek(0, io.SeekStart) 1837 if len(code) != 0 { 1838 errorCode = restjson.SanitizeErrorCode(code) 1839 } 1840 if len(message) != 0 { 1841 errorMessage = message 1842 } 1843 1844 switch { 1845 case strings.EqualFold("InvalidJobStateException", errorCode): 1846 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 1847 1848 case strings.EqualFold("InvalidResourceException", errorCode): 1849 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1850 1851 default: 1852 genericError := &smithy.GenericAPIError{ 1853 Code: errorCode, 1854 Message: errorMessage, 1855 } 1856 return genericError 1857 1858 } 1859} 1860 1861type awsAwsjson11_deserializeOpListClusterJobs struct { 1862} 1863 1864func (*awsAwsjson11_deserializeOpListClusterJobs) ID() string { 1865 return "OperationDeserializer" 1866} 1867 1868func (m *awsAwsjson11_deserializeOpListClusterJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1869 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1870) { 1871 out, metadata, err = next.HandleDeserialize(ctx, in) 1872 if err != nil { 1873 return out, metadata, err 1874 } 1875 1876 response, ok := out.RawResponse.(*smithyhttp.Response) 1877 if !ok { 1878 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1879 } 1880 1881 if response.StatusCode < 200 || response.StatusCode >= 300 { 1882 return out, metadata, awsAwsjson11_deserializeOpErrorListClusterJobs(response, &metadata) 1883 } 1884 output := &ListClusterJobsOutput{} 1885 out.Result = output 1886 1887 var buff [1024]byte 1888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1889 1890 body := io.TeeReader(response.Body, ringBuffer) 1891 decoder := json.NewDecoder(body) 1892 decoder.UseNumber() 1893 var shape interface{} 1894 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1895 var snapshot bytes.Buffer 1896 io.Copy(&snapshot, ringBuffer) 1897 err = &smithy.DeserializationError{ 1898 Err: fmt.Errorf("failed to decode response body, %w", err), 1899 Snapshot: snapshot.Bytes(), 1900 } 1901 return out, metadata, err 1902 } 1903 1904 err = awsAwsjson11_deserializeOpDocumentListClusterJobsOutput(&output, shape) 1905 if err != nil { 1906 var snapshot bytes.Buffer 1907 io.Copy(&snapshot, ringBuffer) 1908 err = &smithy.DeserializationError{ 1909 Err: fmt.Errorf("failed to decode response body, %w", err), 1910 Snapshot: snapshot.Bytes(), 1911 } 1912 return out, metadata, err 1913 } 1914 1915 return out, metadata, err 1916} 1917 1918func awsAwsjson11_deserializeOpErrorListClusterJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1919 var errorBuffer bytes.Buffer 1920 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1921 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1922 } 1923 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1924 1925 errorCode := "UnknownError" 1926 errorMessage := errorCode 1927 1928 code := response.Header.Get("X-Amzn-ErrorType") 1929 if len(code) != 0 { 1930 errorCode = restjson.SanitizeErrorCode(code) 1931 } 1932 1933 var buff [1024]byte 1934 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1935 1936 body := io.TeeReader(errorBody, ringBuffer) 1937 decoder := json.NewDecoder(body) 1938 decoder.UseNumber() 1939 code, message, err := restjson.GetErrorInfo(decoder) 1940 if err != nil { 1941 var snapshot bytes.Buffer 1942 io.Copy(&snapshot, ringBuffer) 1943 err = &smithy.DeserializationError{ 1944 Err: fmt.Errorf("failed to decode response body, %w", err), 1945 Snapshot: snapshot.Bytes(), 1946 } 1947 return err 1948 } 1949 1950 errorBody.Seek(0, io.SeekStart) 1951 if len(code) != 0 { 1952 errorCode = restjson.SanitizeErrorCode(code) 1953 } 1954 if len(message) != 0 { 1955 errorMessage = message 1956 } 1957 1958 switch { 1959 case strings.EqualFold("InvalidNextTokenException", errorCode): 1960 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1961 1962 case strings.EqualFold("InvalidResourceException", errorCode): 1963 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 1964 1965 default: 1966 genericError := &smithy.GenericAPIError{ 1967 Code: errorCode, 1968 Message: errorMessage, 1969 } 1970 return genericError 1971 1972 } 1973} 1974 1975type awsAwsjson11_deserializeOpListClusters struct { 1976} 1977 1978func (*awsAwsjson11_deserializeOpListClusters) ID() string { 1979 return "OperationDeserializer" 1980} 1981 1982func (m *awsAwsjson11_deserializeOpListClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1983 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1984) { 1985 out, metadata, err = next.HandleDeserialize(ctx, in) 1986 if err != nil { 1987 return out, metadata, err 1988 } 1989 1990 response, ok := out.RawResponse.(*smithyhttp.Response) 1991 if !ok { 1992 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1993 } 1994 1995 if response.StatusCode < 200 || response.StatusCode >= 300 { 1996 return out, metadata, awsAwsjson11_deserializeOpErrorListClusters(response, &metadata) 1997 } 1998 output := &ListClustersOutput{} 1999 out.Result = output 2000 2001 var buff [1024]byte 2002 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2003 2004 body := io.TeeReader(response.Body, ringBuffer) 2005 decoder := json.NewDecoder(body) 2006 decoder.UseNumber() 2007 var shape interface{} 2008 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2009 var snapshot bytes.Buffer 2010 io.Copy(&snapshot, ringBuffer) 2011 err = &smithy.DeserializationError{ 2012 Err: fmt.Errorf("failed to decode response body, %w", err), 2013 Snapshot: snapshot.Bytes(), 2014 } 2015 return out, metadata, err 2016 } 2017 2018 err = awsAwsjson11_deserializeOpDocumentListClustersOutput(&output, shape) 2019 if err != nil { 2020 var snapshot bytes.Buffer 2021 io.Copy(&snapshot, ringBuffer) 2022 err = &smithy.DeserializationError{ 2023 Err: fmt.Errorf("failed to decode response body, %w", err), 2024 Snapshot: snapshot.Bytes(), 2025 } 2026 return out, metadata, err 2027 } 2028 2029 return out, metadata, err 2030} 2031 2032func awsAwsjson11_deserializeOpErrorListClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2033 var errorBuffer bytes.Buffer 2034 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2035 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2036 } 2037 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2038 2039 errorCode := "UnknownError" 2040 errorMessage := errorCode 2041 2042 code := response.Header.Get("X-Amzn-ErrorType") 2043 if len(code) != 0 { 2044 errorCode = restjson.SanitizeErrorCode(code) 2045 } 2046 2047 var buff [1024]byte 2048 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2049 2050 body := io.TeeReader(errorBody, ringBuffer) 2051 decoder := json.NewDecoder(body) 2052 decoder.UseNumber() 2053 code, message, err := restjson.GetErrorInfo(decoder) 2054 if err != nil { 2055 var snapshot bytes.Buffer 2056 io.Copy(&snapshot, ringBuffer) 2057 err = &smithy.DeserializationError{ 2058 Err: fmt.Errorf("failed to decode response body, %w", err), 2059 Snapshot: snapshot.Bytes(), 2060 } 2061 return err 2062 } 2063 2064 errorBody.Seek(0, io.SeekStart) 2065 if len(code) != 0 { 2066 errorCode = restjson.SanitizeErrorCode(code) 2067 } 2068 if len(message) != 0 { 2069 errorMessage = message 2070 } 2071 2072 switch { 2073 case strings.EqualFold("InvalidNextTokenException", errorCode): 2074 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2075 2076 default: 2077 genericError := &smithy.GenericAPIError{ 2078 Code: errorCode, 2079 Message: errorMessage, 2080 } 2081 return genericError 2082 2083 } 2084} 2085 2086type awsAwsjson11_deserializeOpListCompatibleImages struct { 2087} 2088 2089func (*awsAwsjson11_deserializeOpListCompatibleImages) ID() string { 2090 return "OperationDeserializer" 2091} 2092 2093func (m *awsAwsjson11_deserializeOpListCompatibleImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2094 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2095) { 2096 out, metadata, err = next.HandleDeserialize(ctx, in) 2097 if err != nil { 2098 return out, metadata, err 2099 } 2100 2101 response, ok := out.RawResponse.(*smithyhttp.Response) 2102 if !ok { 2103 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2104 } 2105 2106 if response.StatusCode < 200 || response.StatusCode >= 300 { 2107 return out, metadata, awsAwsjson11_deserializeOpErrorListCompatibleImages(response, &metadata) 2108 } 2109 output := &ListCompatibleImagesOutput{} 2110 out.Result = output 2111 2112 var buff [1024]byte 2113 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2114 2115 body := io.TeeReader(response.Body, ringBuffer) 2116 decoder := json.NewDecoder(body) 2117 decoder.UseNumber() 2118 var shape interface{} 2119 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2120 var snapshot bytes.Buffer 2121 io.Copy(&snapshot, ringBuffer) 2122 err = &smithy.DeserializationError{ 2123 Err: fmt.Errorf("failed to decode response body, %w", err), 2124 Snapshot: snapshot.Bytes(), 2125 } 2126 return out, metadata, err 2127 } 2128 2129 err = awsAwsjson11_deserializeOpDocumentListCompatibleImagesOutput(&output, shape) 2130 if err != nil { 2131 var snapshot bytes.Buffer 2132 io.Copy(&snapshot, ringBuffer) 2133 err = &smithy.DeserializationError{ 2134 Err: fmt.Errorf("failed to decode response body, %w", err), 2135 Snapshot: snapshot.Bytes(), 2136 } 2137 return out, metadata, err 2138 } 2139 2140 return out, metadata, err 2141} 2142 2143func awsAwsjson11_deserializeOpErrorListCompatibleImages(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2144 var errorBuffer bytes.Buffer 2145 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2146 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2147 } 2148 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2149 2150 errorCode := "UnknownError" 2151 errorMessage := errorCode 2152 2153 code := response.Header.Get("X-Amzn-ErrorType") 2154 if len(code) != 0 { 2155 errorCode = restjson.SanitizeErrorCode(code) 2156 } 2157 2158 var buff [1024]byte 2159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2160 2161 body := io.TeeReader(errorBody, ringBuffer) 2162 decoder := json.NewDecoder(body) 2163 decoder.UseNumber() 2164 code, message, err := restjson.GetErrorInfo(decoder) 2165 if err != nil { 2166 var snapshot bytes.Buffer 2167 io.Copy(&snapshot, ringBuffer) 2168 err = &smithy.DeserializationError{ 2169 Err: fmt.Errorf("failed to decode response body, %w", err), 2170 Snapshot: snapshot.Bytes(), 2171 } 2172 return err 2173 } 2174 2175 errorBody.Seek(0, io.SeekStart) 2176 if len(code) != 0 { 2177 errorCode = restjson.SanitizeErrorCode(code) 2178 } 2179 if len(message) != 0 { 2180 errorMessage = message 2181 } 2182 2183 switch { 2184 case strings.EqualFold("Ec2RequestFailedException", errorCode): 2185 return awsAwsjson11_deserializeErrorEc2RequestFailedException(response, errorBody) 2186 2187 case strings.EqualFold("InvalidNextTokenException", errorCode): 2188 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2189 2190 default: 2191 genericError := &smithy.GenericAPIError{ 2192 Code: errorCode, 2193 Message: errorMessage, 2194 } 2195 return genericError 2196 2197 } 2198} 2199 2200type awsAwsjson11_deserializeOpListJobs struct { 2201} 2202 2203func (*awsAwsjson11_deserializeOpListJobs) ID() string { 2204 return "OperationDeserializer" 2205} 2206 2207func (m *awsAwsjson11_deserializeOpListJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2208 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2209) { 2210 out, metadata, err = next.HandleDeserialize(ctx, in) 2211 if err != nil { 2212 return out, metadata, err 2213 } 2214 2215 response, ok := out.RawResponse.(*smithyhttp.Response) 2216 if !ok { 2217 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2218 } 2219 2220 if response.StatusCode < 200 || response.StatusCode >= 300 { 2221 return out, metadata, awsAwsjson11_deserializeOpErrorListJobs(response, &metadata) 2222 } 2223 output := &ListJobsOutput{} 2224 out.Result = output 2225 2226 var buff [1024]byte 2227 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2228 2229 body := io.TeeReader(response.Body, ringBuffer) 2230 decoder := json.NewDecoder(body) 2231 decoder.UseNumber() 2232 var shape interface{} 2233 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2234 var snapshot bytes.Buffer 2235 io.Copy(&snapshot, ringBuffer) 2236 err = &smithy.DeserializationError{ 2237 Err: fmt.Errorf("failed to decode response body, %w", err), 2238 Snapshot: snapshot.Bytes(), 2239 } 2240 return out, metadata, err 2241 } 2242 2243 err = awsAwsjson11_deserializeOpDocumentListJobsOutput(&output, shape) 2244 if err != nil { 2245 var snapshot bytes.Buffer 2246 io.Copy(&snapshot, ringBuffer) 2247 err = &smithy.DeserializationError{ 2248 Err: fmt.Errorf("failed to decode response body, %w", err), 2249 Snapshot: snapshot.Bytes(), 2250 } 2251 return out, metadata, err 2252 } 2253 2254 return out, metadata, err 2255} 2256 2257func awsAwsjson11_deserializeOpErrorListJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2258 var errorBuffer bytes.Buffer 2259 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2260 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2261 } 2262 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2263 2264 errorCode := "UnknownError" 2265 errorMessage := errorCode 2266 2267 code := response.Header.Get("X-Amzn-ErrorType") 2268 if len(code) != 0 { 2269 errorCode = restjson.SanitizeErrorCode(code) 2270 } 2271 2272 var buff [1024]byte 2273 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2274 2275 body := io.TeeReader(errorBody, ringBuffer) 2276 decoder := json.NewDecoder(body) 2277 decoder.UseNumber() 2278 code, message, err := restjson.GetErrorInfo(decoder) 2279 if err != nil { 2280 var snapshot bytes.Buffer 2281 io.Copy(&snapshot, ringBuffer) 2282 err = &smithy.DeserializationError{ 2283 Err: fmt.Errorf("failed to decode response body, %w", err), 2284 Snapshot: snapshot.Bytes(), 2285 } 2286 return err 2287 } 2288 2289 errorBody.Seek(0, io.SeekStart) 2290 if len(code) != 0 { 2291 errorCode = restjson.SanitizeErrorCode(code) 2292 } 2293 if len(message) != 0 { 2294 errorMessage = message 2295 } 2296 2297 switch { 2298 case strings.EqualFold("InvalidNextTokenException", errorCode): 2299 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2300 2301 default: 2302 genericError := &smithy.GenericAPIError{ 2303 Code: errorCode, 2304 Message: errorMessage, 2305 } 2306 return genericError 2307 2308 } 2309} 2310 2311type awsAwsjson11_deserializeOpListLongTermPricing struct { 2312} 2313 2314func (*awsAwsjson11_deserializeOpListLongTermPricing) ID() string { 2315 return "OperationDeserializer" 2316} 2317 2318func (m *awsAwsjson11_deserializeOpListLongTermPricing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2319 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2320) { 2321 out, metadata, err = next.HandleDeserialize(ctx, in) 2322 if err != nil { 2323 return out, metadata, err 2324 } 2325 2326 response, ok := out.RawResponse.(*smithyhttp.Response) 2327 if !ok { 2328 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2329 } 2330 2331 if response.StatusCode < 200 || response.StatusCode >= 300 { 2332 return out, metadata, awsAwsjson11_deserializeOpErrorListLongTermPricing(response, &metadata) 2333 } 2334 output := &ListLongTermPricingOutput{} 2335 out.Result = output 2336 2337 var buff [1024]byte 2338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2339 2340 body := io.TeeReader(response.Body, ringBuffer) 2341 decoder := json.NewDecoder(body) 2342 decoder.UseNumber() 2343 var shape interface{} 2344 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2345 var snapshot bytes.Buffer 2346 io.Copy(&snapshot, ringBuffer) 2347 err = &smithy.DeserializationError{ 2348 Err: fmt.Errorf("failed to decode response body, %w", err), 2349 Snapshot: snapshot.Bytes(), 2350 } 2351 return out, metadata, err 2352 } 2353 2354 err = awsAwsjson11_deserializeOpDocumentListLongTermPricingOutput(&output, shape) 2355 if err != nil { 2356 var snapshot bytes.Buffer 2357 io.Copy(&snapshot, ringBuffer) 2358 err = &smithy.DeserializationError{ 2359 Err: fmt.Errorf("failed to decode response body, %w", err), 2360 Snapshot: snapshot.Bytes(), 2361 } 2362 return out, metadata, err 2363 } 2364 2365 return out, metadata, err 2366} 2367 2368func awsAwsjson11_deserializeOpErrorListLongTermPricing(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2369 var errorBuffer bytes.Buffer 2370 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2371 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2372 } 2373 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2374 2375 errorCode := "UnknownError" 2376 errorMessage := errorCode 2377 2378 code := response.Header.Get("X-Amzn-ErrorType") 2379 if len(code) != 0 { 2380 errorCode = restjson.SanitizeErrorCode(code) 2381 } 2382 2383 var buff [1024]byte 2384 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2385 2386 body := io.TeeReader(errorBody, ringBuffer) 2387 decoder := json.NewDecoder(body) 2388 decoder.UseNumber() 2389 code, message, err := restjson.GetErrorInfo(decoder) 2390 if err != nil { 2391 var snapshot bytes.Buffer 2392 io.Copy(&snapshot, ringBuffer) 2393 err = &smithy.DeserializationError{ 2394 Err: fmt.Errorf("failed to decode response body, %w", err), 2395 Snapshot: snapshot.Bytes(), 2396 } 2397 return err 2398 } 2399 2400 errorBody.Seek(0, io.SeekStart) 2401 if len(code) != 0 { 2402 errorCode = restjson.SanitizeErrorCode(code) 2403 } 2404 if len(message) != 0 { 2405 errorMessage = message 2406 } 2407 2408 switch { 2409 case strings.EqualFold("InvalidNextTokenException", errorCode): 2410 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 2411 2412 case strings.EqualFold("InvalidResourceException", errorCode): 2413 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 2414 2415 default: 2416 genericError := &smithy.GenericAPIError{ 2417 Code: errorCode, 2418 Message: errorMessage, 2419 } 2420 return genericError 2421 2422 } 2423} 2424 2425type awsAwsjson11_deserializeOpUpdateCluster struct { 2426} 2427 2428func (*awsAwsjson11_deserializeOpUpdateCluster) ID() string { 2429 return "OperationDeserializer" 2430} 2431 2432func (m *awsAwsjson11_deserializeOpUpdateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2433 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2434) { 2435 out, metadata, err = next.HandleDeserialize(ctx, in) 2436 if err != nil { 2437 return out, metadata, err 2438 } 2439 2440 response, ok := out.RawResponse.(*smithyhttp.Response) 2441 if !ok { 2442 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2443 } 2444 2445 if response.StatusCode < 200 || response.StatusCode >= 300 { 2446 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCluster(response, &metadata) 2447 } 2448 output := &UpdateClusterOutput{} 2449 out.Result = output 2450 2451 var buff [1024]byte 2452 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2453 2454 body := io.TeeReader(response.Body, ringBuffer) 2455 decoder := json.NewDecoder(body) 2456 decoder.UseNumber() 2457 var shape interface{} 2458 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2459 var snapshot bytes.Buffer 2460 io.Copy(&snapshot, ringBuffer) 2461 err = &smithy.DeserializationError{ 2462 Err: fmt.Errorf("failed to decode response body, %w", err), 2463 Snapshot: snapshot.Bytes(), 2464 } 2465 return out, metadata, err 2466 } 2467 2468 err = awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(&output, shape) 2469 if err != nil { 2470 var snapshot bytes.Buffer 2471 io.Copy(&snapshot, ringBuffer) 2472 err = &smithy.DeserializationError{ 2473 Err: fmt.Errorf("failed to decode response body, %w", err), 2474 Snapshot: snapshot.Bytes(), 2475 } 2476 return out, metadata, err 2477 } 2478 2479 return out, metadata, err 2480} 2481 2482func awsAwsjson11_deserializeOpErrorUpdateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2483 var errorBuffer bytes.Buffer 2484 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2485 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2486 } 2487 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2488 2489 errorCode := "UnknownError" 2490 errorMessage := errorCode 2491 2492 code := response.Header.Get("X-Amzn-ErrorType") 2493 if len(code) != 0 { 2494 errorCode = restjson.SanitizeErrorCode(code) 2495 } 2496 2497 var buff [1024]byte 2498 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2499 2500 body := io.TeeReader(errorBody, ringBuffer) 2501 decoder := json.NewDecoder(body) 2502 decoder.UseNumber() 2503 code, message, err := restjson.GetErrorInfo(decoder) 2504 if err != nil { 2505 var snapshot bytes.Buffer 2506 io.Copy(&snapshot, ringBuffer) 2507 err = &smithy.DeserializationError{ 2508 Err: fmt.Errorf("failed to decode response body, %w", err), 2509 Snapshot: snapshot.Bytes(), 2510 } 2511 return err 2512 } 2513 2514 errorBody.Seek(0, io.SeekStart) 2515 if len(code) != 0 { 2516 errorCode = restjson.SanitizeErrorCode(code) 2517 } 2518 if len(message) != 0 { 2519 errorMessage = message 2520 } 2521 2522 switch { 2523 case strings.EqualFold("Ec2RequestFailedException", errorCode): 2524 return awsAwsjson11_deserializeErrorEc2RequestFailedException(response, errorBody) 2525 2526 case strings.EqualFold("InvalidInputCombinationException", errorCode): 2527 return awsAwsjson11_deserializeErrorInvalidInputCombinationException(response, errorBody) 2528 2529 case strings.EqualFold("InvalidJobStateException", errorCode): 2530 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 2531 2532 case strings.EqualFold("InvalidResourceException", errorCode): 2533 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 2534 2535 case strings.EqualFold("KMSRequestFailedException", errorCode): 2536 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 2537 2538 default: 2539 genericError := &smithy.GenericAPIError{ 2540 Code: errorCode, 2541 Message: errorMessage, 2542 } 2543 return genericError 2544 2545 } 2546} 2547 2548type awsAwsjson11_deserializeOpUpdateJob struct { 2549} 2550 2551func (*awsAwsjson11_deserializeOpUpdateJob) ID() string { 2552 return "OperationDeserializer" 2553} 2554 2555func (m *awsAwsjson11_deserializeOpUpdateJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2556 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2557) { 2558 out, metadata, err = next.HandleDeserialize(ctx, in) 2559 if err != nil { 2560 return out, metadata, err 2561 } 2562 2563 response, ok := out.RawResponse.(*smithyhttp.Response) 2564 if !ok { 2565 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2566 } 2567 2568 if response.StatusCode < 200 || response.StatusCode >= 300 { 2569 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateJob(response, &metadata) 2570 } 2571 output := &UpdateJobOutput{} 2572 out.Result = output 2573 2574 var buff [1024]byte 2575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2576 2577 body := io.TeeReader(response.Body, ringBuffer) 2578 decoder := json.NewDecoder(body) 2579 decoder.UseNumber() 2580 var shape interface{} 2581 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2582 var snapshot bytes.Buffer 2583 io.Copy(&snapshot, ringBuffer) 2584 err = &smithy.DeserializationError{ 2585 Err: fmt.Errorf("failed to decode response body, %w", err), 2586 Snapshot: snapshot.Bytes(), 2587 } 2588 return out, metadata, err 2589 } 2590 2591 err = awsAwsjson11_deserializeOpDocumentUpdateJobOutput(&output, shape) 2592 if err != nil { 2593 var snapshot bytes.Buffer 2594 io.Copy(&snapshot, ringBuffer) 2595 err = &smithy.DeserializationError{ 2596 Err: fmt.Errorf("failed to decode response body, %w", err), 2597 Snapshot: snapshot.Bytes(), 2598 } 2599 return out, metadata, err 2600 } 2601 2602 return out, metadata, err 2603} 2604 2605func awsAwsjson11_deserializeOpErrorUpdateJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2606 var errorBuffer bytes.Buffer 2607 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2608 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2609 } 2610 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2611 2612 errorCode := "UnknownError" 2613 errorMessage := errorCode 2614 2615 code := response.Header.Get("X-Amzn-ErrorType") 2616 if len(code) != 0 { 2617 errorCode = restjson.SanitizeErrorCode(code) 2618 } 2619 2620 var buff [1024]byte 2621 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2622 2623 body := io.TeeReader(errorBody, ringBuffer) 2624 decoder := json.NewDecoder(body) 2625 decoder.UseNumber() 2626 code, message, err := restjson.GetErrorInfo(decoder) 2627 if err != nil { 2628 var snapshot bytes.Buffer 2629 io.Copy(&snapshot, ringBuffer) 2630 err = &smithy.DeserializationError{ 2631 Err: fmt.Errorf("failed to decode response body, %w", err), 2632 Snapshot: snapshot.Bytes(), 2633 } 2634 return err 2635 } 2636 2637 errorBody.Seek(0, io.SeekStart) 2638 if len(code) != 0 { 2639 errorCode = restjson.SanitizeErrorCode(code) 2640 } 2641 if len(message) != 0 { 2642 errorMessage = message 2643 } 2644 2645 switch { 2646 case strings.EqualFold("ClusterLimitExceededException", errorCode): 2647 return awsAwsjson11_deserializeErrorClusterLimitExceededException(response, errorBody) 2648 2649 case strings.EqualFold("Ec2RequestFailedException", errorCode): 2650 return awsAwsjson11_deserializeErrorEc2RequestFailedException(response, errorBody) 2651 2652 case strings.EqualFold("InvalidInputCombinationException", errorCode): 2653 return awsAwsjson11_deserializeErrorInvalidInputCombinationException(response, errorBody) 2654 2655 case strings.EqualFold("InvalidJobStateException", errorCode): 2656 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 2657 2658 case strings.EqualFold("InvalidResourceException", errorCode): 2659 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 2660 2661 case strings.EqualFold("KMSRequestFailedException", errorCode): 2662 return awsAwsjson11_deserializeErrorKMSRequestFailedException(response, errorBody) 2663 2664 default: 2665 genericError := &smithy.GenericAPIError{ 2666 Code: errorCode, 2667 Message: errorMessage, 2668 } 2669 return genericError 2670 2671 } 2672} 2673 2674type awsAwsjson11_deserializeOpUpdateJobShipmentState struct { 2675} 2676 2677func (*awsAwsjson11_deserializeOpUpdateJobShipmentState) ID() string { 2678 return "OperationDeserializer" 2679} 2680 2681func (m *awsAwsjson11_deserializeOpUpdateJobShipmentState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2682 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2683) { 2684 out, metadata, err = next.HandleDeserialize(ctx, in) 2685 if err != nil { 2686 return out, metadata, err 2687 } 2688 2689 response, ok := out.RawResponse.(*smithyhttp.Response) 2690 if !ok { 2691 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2692 } 2693 2694 if response.StatusCode < 200 || response.StatusCode >= 300 { 2695 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateJobShipmentState(response, &metadata) 2696 } 2697 output := &UpdateJobShipmentStateOutput{} 2698 out.Result = output 2699 2700 var buff [1024]byte 2701 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2702 2703 body := io.TeeReader(response.Body, ringBuffer) 2704 decoder := json.NewDecoder(body) 2705 decoder.UseNumber() 2706 var shape interface{} 2707 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2708 var snapshot bytes.Buffer 2709 io.Copy(&snapshot, ringBuffer) 2710 err = &smithy.DeserializationError{ 2711 Err: fmt.Errorf("failed to decode response body, %w", err), 2712 Snapshot: snapshot.Bytes(), 2713 } 2714 return out, metadata, err 2715 } 2716 2717 err = awsAwsjson11_deserializeOpDocumentUpdateJobShipmentStateOutput(&output, shape) 2718 if err != nil { 2719 var snapshot bytes.Buffer 2720 io.Copy(&snapshot, ringBuffer) 2721 err = &smithy.DeserializationError{ 2722 Err: fmt.Errorf("failed to decode response body, %w", err), 2723 Snapshot: snapshot.Bytes(), 2724 } 2725 return out, metadata, err 2726 } 2727 2728 return out, metadata, err 2729} 2730 2731func awsAwsjson11_deserializeOpErrorUpdateJobShipmentState(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2732 var errorBuffer bytes.Buffer 2733 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2734 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2735 } 2736 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2737 2738 errorCode := "UnknownError" 2739 errorMessage := errorCode 2740 2741 code := response.Header.Get("X-Amzn-ErrorType") 2742 if len(code) != 0 { 2743 errorCode = restjson.SanitizeErrorCode(code) 2744 } 2745 2746 var buff [1024]byte 2747 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2748 2749 body := io.TeeReader(errorBody, ringBuffer) 2750 decoder := json.NewDecoder(body) 2751 decoder.UseNumber() 2752 code, message, err := restjson.GetErrorInfo(decoder) 2753 if err != nil { 2754 var snapshot bytes.Buffer 2755 io.Copy(&snapshot, ringBuffer) 2756 err = &smithy.DeserializationError{ 2757 Err: fmt.Errorf("failed to decode response body, %w", err), 2758 Snapshot: snapshot.Bytes(), 2759 } 2760 return err 2761 } 2762 2763 errorBody.Seek(0, io.SeekStart) 2764 if len(code) != 0 { 2765 errorCode = restjson.SanitizeErrorCode(code) 2766 } 2767 if len(message) != 0 { 2768 errorMessage = message 2769 } 2770 2771 switch { 2772 case strings.EqualFold("InvalidJobStateException", errorCode): 2773 return awsAwsjson11_deserializeErrorInvalidJobStateException(response, errorBody) 2774 2775 case strings.EqualFold("InvalidResourceException", errorCode): 2776 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 2777 2778 default: 2779 genericError := &smithy.GenericAPIError{ 2780 Code: errorCode, 2781 Message: errorMessage, 2782 } 2783 return genericError 2784 2785 } 2786} 2787 2788type awsAwsjson11_deserializeOpUpdateLongTermPricing struct { 2789} 2790 2791func (*awsAwsjson11_deserializeOpUpdateLongTermPricing) ID() string { 2792 return "OperationDeserializer" 2793} 2794 2795func (m *awsAwsjson11_deserializeOpUpdateLongTermPricing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2796 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2797) { 2798 out, metadata, err = next.HandleDeserialize(ctx, in) 2799 if err != nil { 2800 return out, metadata, err 2801 } 2802 2803 response, ok := out.RawResponse.(*smithyhttp.Response) 2804 if !ok { 2805 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2806 } 2807 2808 if response.StatusCode < 200 || response.StatusCode >= 300 { 2809 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLongTermPricing(response, &metadata) 2810 } 2811 output := &UpdateLongTermPricingOutput{} 2812 out.Result = output 2813 2814 var buff [1024]byte 2815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2816 2817 body := io.TeeReader(response.Body, ringBuffer) 2818 decoder := json.NewDecoder(body) 2819 decoder.UseNumber() 2820 var shape interface{} 2821 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2822 var snapshot bytes.Buffer 2823 io.Copy(&snapshot, ringBuffer) 2824 err = &smithy.DeserializationError{ 2825 Err: fmt.Errorf("failed to decode response body, %w", err), 2826 Snapshot: snapshot.Bytes(), 2827 } 2828 return out, metadata, err 2829 } 2830 2831 err = awsAwsjson11_deserializeOpDocumentUpdateLongTermPricingOutput(&output, shape) 2832 if err != nil { 2833 var snapshot bytes.Buffer 2834 io.Copy(&snapshot, ringBuffer) 2835 err = &smithy.DeserializationError{ 2836 Err: fmt.Errorf("failed to decode response body, %w", err), 2837 Snapshot: snapshot.Bytes(), 2838 } 2839 return out, metadata, err 2840 } 2841 2842 return out, metadata, err 2843} 2844 2845func awsAwsjson11_deserializeOpErrorUpdateLongTermPricing(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2846 var errorBuffer bytes.Buffer 2847 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2848 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2849 } 2850 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2851 2852 errorCode := "UnknownError" 2853 errorMessage := errorCode 2854 2855 code := response.Header.Get("X-Amzn-ErrorType") 2856 if len(code) != 0 { 2857 errorCode = restjson.SanitizeErrorCode(code) 2858 } 2859 2860 var buff [1024]byte 2861 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2862 2863 body := io.TeeReader(errorBody, ringBuffer) 2864 decoder := json.NewDecoder(body) 2865 decoder.UseNumber() 2866 code, message, err := restjson.GetErrorInfo(decoder) 2867 if err != nil { 2868 var snapshot bytes.Buffer 2869 io.Copy(&snapshot, ringBuffer) 2870 err = &smithy.DeserializationError{ 2871 Err: fmt.Errorf("failed to decode response body, %w", err), 2872 Snapshot: snapshot.Bytes(), 2873 } 2874 return err 2875 } 2876 2877 errorBody.Seek(0, io.SeekStart) 2878 if len(code) != 0 { 2879 errorCode = restjson.SanitizeErrorCode(code) 2880 } 2881 if len(message) != 0 { 2882 errorMessage = message 2883 } 2884 2885 switch { 2886 case strings.EqualFold("InvalidResourceException", errorCode): 2887 return awsAwsjson11_deserializeErrorInvalidResourceException(response, errorBody) 2888 2889 default: 2890 genericError := &smithy.GenericAPIError{ 2891 Code: errorCode, 2892 Message: errorMessage, 2893 } 2894 return genericError 2895 2896 } 2897} 2898 2899func awsAwsjson11_deserializeErrorClusterLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2900 var buff [1024]byte 2901 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2902 2903 body := io.TeeReader(errorBody, ringBuffer) 2904 decoder := json.NewDecoder(body) 2905 decoder.UseNumber() 2906 var shape interface{} 2907 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2908 var snapshot bytes.Buffer 2909 io.Copy(&snapshot, ringBuffer) 2910 err = &smithy.DeserializationError{ 2911 Err: fmt.Errorf("failed to decode response body, %w", err), 2912 Snapshot: snapshot.Bytes(), 2913 } 2914 return err 2915 } 2916 2917 output := &types.ClusterLimitExceededException{} 2918 err := awsAwsjson11_deserializeDocumentClusterLimitExceededException(&output, shape) 2919 2920 if err != nil { 2921 var snapshot bytes.Buffer 2922 io.Copy(&snapshot, ringBuffer) 2923 err = &smithy.DeserializationError{ 2924 Err: fmt.Errorf("failed to decode response body, %w", err), 2925 Snapshot: snapshot.Bytes(), 2926 } 2927 return err 2928 } 2929 2930 errorBody.Seek(0, io.SeekStart) 2931 return output 2932} 2933 2934func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2935 var buff [1024]byte 2936 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2937 2938 body := io.TeeReader(errorBody, ringBuffer) 2939 decoder := json.NewDecoder(body) 2940 decoder.UseNumber() 2941 var shape interface{} 2942 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2943 var snapshot bytes.Buffer 2944 io.Copy(&snapshot, ringBuffer) 2945 err = &smithy.DeserializationError{ 2946 Err: fmt.Errorf("failed to decode response body, %w", err), 2947 Snapshot: snapshot.Bytes(), 2948 } 2949 return err 2950 } 2951 2952 output := &types.ConflictException{} 2953 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 2954 2955 if err != nil { 2956 var snapshot bytes.Buffer 2957 io.Copy(&snapshot, ringBuffer) 2958 err = &smithy.DeserializationError{ 2959 Err: fmt.Errorf("failed to decode response body, %w", err), 2960 Snapshot: snapshot.Bytes(), 2961 } 2962 return err 2963 } 2964 2965 errorBody.Seek(0, io.SeekStart) 2966 return output 2967} 2968 2969func awsAwsjson11_deserializeErrorEc2RequestFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2970 var buff [1024]byte 2971 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2972 2973 body := io.TeeReader(errorBody, ringBuffer) 2974 decoder := json.NewDecoder(body) 2975 decoder.UseNumber() 2976 var shape interface{} 2977 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2978 var snapshot bytes.Buffer 2979 io.Copy(&snapshot, ringBuffer) 2980 err = &smithy.DeserializationError{ 2981 Err: fmt.Errorf("failed to decode response body, %w", err), 2982 Snapshot: snapshot.Bytes(), 2983 } 2984 return err 2985 } 2986 2987 output := &types.Ec2RequestFailedException{} 2988 err := awsAwsjson11_deserializeDocumentEc2RequestFailedException(&output, shape) 2989 2990 if err != nil { 2991 var snapshot bytes.Buffer 2992 io.Copy(&snapshot, ringBuffer) 2993 err = &smithy.DeserializationError{ 2994 Err: fmt.Errorf("failed to decode response body, %w", err), 2995 Snapshot: snapshot.Bytes(), 2996 } 2997 return err 2998 } 2999 3000 errorBody.Seek(0, io.SeekStart) 3001 return output 3002} 3003 3004func awsAwsjson11_deserializeErrorInvalidAddressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3005 var buff [1024]byte 3006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3007 3008 body := io.TeeReader(errorBody, ringBuffer) 3009 decoder := json.NewDecoder(body) 3010 decoder.UseNumber() 3011 var shape interface{} 3012 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3013 var snapshot bytes.Buffer 3014 io.Copy(&snapshot, ringBuffer) 3015 err = &smithy.DeserializationError{ 3016 Err: fmt.Errorf("failed to decode response body, %w", err), 3017 Snapshot: snapshot.Bytes(), 3018 } 3019 return err 3020 } 3021 3022 output := &types.InvalidAddressException{} 3023 err := awsAwsjson11_deserializeDocumentInvalidAddressException(&output, shape) 3024 3025 if err != nil { 3026 var snapshot bytes.Buffer 3027 io.Copy(&snapshot, ringBuffer) 3028 err = &smithy.DeserializationError{ 3029 Err: fmt.Errorf("failed to decode response body, %w", err), 3030 Snapshot: snapshot.Bytes(), 3031 } 3032 return err 3033 } 3034 3035 errorBody.Seek(0, io.SeekStart) 3036 return output 3037} 3038 3039func awsAwsjson11_deserializeErrorInvalidInputCombinationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3040 var buff [1024]byte 3041 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3042 3043 body := io.TeeReader(errorBody, ringBuffer) 3044 decoder := json.NewDecoder(body) 3045 decoder.UseNumber() 3046 var shape interface{} 3047 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3048 var snapshot bytes.Buffer 3049 io.Copy(&snapshot, ringBuffer) 3050 err = &smithy.DeserializationError{ 3051 Err: fmt.Errorf("failed to decode response body, %w", err), 3052 Snapshot: snapshot.Bytes(), 3053 } 3054 return err 3055 } 3056 3057 output := &types.InvalidInputCombinationException{} 3058 err := awsAwsjson11_deserializeDocumentInvalidInputCombinationException(&output, shape) 3059 3060 if err != nil { 3061 var snapshot bytes.Buffer 3062 io.Copy(&snapshot, ringBuffer) 3063 err = &smithy.DeserializationError{ 3064 Err: fmt.Errorf("failed to decode response body, %w", err), 3065 Snapshot: snapshot.Bytes(), 3066 } 3067 return err 3068 } 3069 3070 errorBody.Seek(0, io.SeekStart) 3071 return output 3072} 3073 3074func awsAwsjson11_deserializeErrorInvalidJobStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3075 var buff [1024]byte 3076 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3077 3078 body := io.TeeReader(errorBody, ringBuffer) 3079 decoder := json.NewDecoder(body) 3080 decoder.UseNumber() 3081 var shape interface{} 3082 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3083 var snapshot bytes.Buffer 3084 io.Copy(&snapshot, ringBuffer) 3085 err = &smithy.DeserializationError{ 3086 Err: fmt.Errorf("failed to decode response body, %w", err), 3087 Snapshot: snapshot.Bytes(), 3088 } 3089 return err 3090 } 3091 3092 output := &types.InvalidJobStateException{} 3093 err := awsAwsjson11_deserializeDocumentInvalidJobStateException(&output, shape) 3094 3095 if err != nil { 3096 var snapshot bytes.Buffer 3097 io.Copy(&snapshot, ringBuffer) 3098 err = &smithy.DeserializationError{ 3099 Err: fmt.Errorf("failed to decode response body, %w", err), 3100 Snapshot: snapshot.Bytes(), 3101 } 3102 return err 3103 } 3104 3105 errorBody.Seek(0, io.SeekStart) 3106 return output 3107} 3108 3109func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3110 var buff [1024]byte 3111 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3112 3113 body := io.TeeReader(errorBody, ringBuffer) 3114 decoder := json.NewDecoder(body) 3115 decoder.UseNumber() 3116 var shape interface{} 3117 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3118 var snapshot bytes.Buffer 3119 io.Copy(&snapshot, ringBuffer) 3120 err = &smithy.DeserializationError{ 3121 Err: fmt.Errorf("failed to decode response body, %w", err), 3122 Snapshot: snapshot.Bytes(), 3123 } 3124 return err 3125 } 3126 3127 output := &types.InvalidNextTokenException{} 3128 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 3129 3130 if err != nil { 3131 var snapshot bytes.Buffer 3132 io.Copy(&snapshot, ringBuffer) 3133 err = &smithy.DeserializationError{ 3134 Err: fmt.Errorf("failed to decode response body, %w", err), 3135 Snapshot: snapshot.Bytes(), 3136 } 3137 return err 3138 } 3139 3140 errorBody.Seek(0, io.SeekStart) 3141 return output 3142} 3143 3144func awsAwsjson11_deserializeErrorInvalidResourceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3145 var buff [1024]byte 3146 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3147 3148 body := io.TeeReader(errorBody, ringBuffer) 3149 decoder := json.NewDecoder(body) 3150 decoder.UseNumber() 3151 var shape interface{} 3152 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3153 var snapshot bytes.Buffer 3154 io.Copy(&snapshot, ringBuffer) 3155 err = &smithy.DeserializationError{ 3156 Err: fmt.Errorf("failed to decode response body, %w", err), 3157 Snapshot: snapshot.Bytes(), 3158 } 3159 return err 3160 } 3161 3162 output := &types.InvalidResourceException{} 3163 err := awsAwsjson11_deserializeDocumentInvalidResourceException(&output, shape) 3164 3165 if err != nil { 3166 var snapshot bytes.Buffer 3167 io.Copy(&snapshot, ringBuffer) 3168 err = &smithy.DeserializationError{ 3169 Err: fmt.Errorf("failed to decode response body, %w", err), 3170 Snapshot: snapshot.Bytes(), 3171 } 3172 return err 3173 } 3174 3175 errorBody.Seek(0, io.SeekStart) 3176 return output 3177} 3178 3179func awsAwsjson11_deserializeErrorKMSRequestFailedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3180 var buff [1024]byte 3181 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3182 3183 body := io.TeeReader(errorBody, ringBuffer) 3184 decoder := json.NewDecoder(body) 3185 decoder.UseNumber() 3186 var shape interface{} 3187 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3188 var snapshot bytes.Buffer 3189 io.Copy(&snapshot, ringBuffer) 3190 err = &smithy.DeserializationError{ 3191 Err: fmt.Errorf("failed to decode response body, %w", err), 3192 Snapshot: snapshot.Bytes(), 3193 } 3194 return err 3195 } 3196 3197 output := &types.KMSRequestFailedException{} 3198 err := awsAwsjson11_deserializeDocumentKMSRequestFailedException(&output, shape) 3199 3200 if err != nil { 3201 var snapshot bytes.Buffer 3202 io.Copy(&snapshot, ringBuffer) 3203 err = &smithy.DeserializationError{ 3204 Err: fmt.Errorf("failed to decode response body, %w", err), 3205 Snapshot: snapshot.Bytes(), 3206 } 3207 return err 3208 } 3209 3210 errorBody.Seek(0, io.SeekStart) 3211 return output 3212} 3213 3214func awsAwsjson11_deserializeErrorReturnShippingLabelAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3215 var buff [1024]byte 3216 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3217 3218 body := io.TeeReader(errorBody, ringBuffer) 3219 decoder := json.NewDecoder(body) 3220 decoder.UseNumber() 3221 var shape interface{} 3222 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3223 var snapshot bytes.Buffer 3224 io.Copy(&snapshot, ringBuffer) 3225 err = &smithy.DeserializationError{ 3226 Err: fmt.Errorf("failed to decode response body, %w", err), 3227 Snapshot: snapshot.Bytes(), 3228 } 3229 return err 3230 } 3231 3232 output := &types.ReturnShippingLabelAlreadyExistsException{} 3233 err := awsAwsjson11_deserializeDocumentReturnShippingLabelAlreadyExistsException(&output, shape) 3234 3235 if err != nil { 3236 var snapshot bytes.Buffer 3237 io.Copy(&snapshot, ringBuffer) 3238 err = &smithy.DeserializationError{ 3239 Err: fmt.Errorf("failed to decode response body, %w", err), 3240 Snapshot: snapshot.Bytes(), 3241 } 3242 return err 3243 } 3244 3245 errorBody.Seek(0, io.SeekStart) 3246 return output 3247} 3248 3249func awsAwsjson11_deserializeErrorUnsupportedAddressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3250 var buff [1024]byte 3251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3252 3253 body := io.TeeReader(errorBody, ringBuffer) 3254 decoder := json.NewDecoder(body) 3255 decoder.UseNumber() 3256 var shape interface{} 3257 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3258 var snapshot bytes.Buffer 3259 io.Copy(&snapshot, ringBuffer) 3260 err = &smithy.DeserializationError{ 3261 Err: fmt.Errorf("failed to decode response body, %w", err), 3262 Snapshot: snapshot.Bytes(), 3263 } 3264 return err 3265 } 3266 3267 output := &types.UnsupportedAddressException{} 3268 err := awsAwsjson11_deserializeDocumentUnsupportedAddressException(&output, shape) 3269 3270 if err != nil { 3271 var snapshot bytes.Buffer 3272 io.Copy(&snapshot, ringBuffer) 3273 err = &smithy.DeserializationError{ 3274 Err: fmt.Errorf("failed to decode response body, %w", err), 3275 Snapshot: snapshot.Bytes(), 3276 } 3277 return err 3278 } 3279 3280 errorBody.Seek(0, io.SeekStart) 3281 return output 3282} 3283 3284func awsAwsjson11_deserializeDocumentAddress(v **types.Address, value interface{}) error { 3285 if v == nil { 3286 return fmt.Errorf("unexpected nil of type %T", v) 3287 } 3288 if value == nil { 3289 return nil 3290 } 3291 3292 shape, ok := value.(map[string]interface{}) 3293 if !ok { 3294 return fmt.Errorf("unexpected JSON type %v", value) 3295 } 3296 3297 var sv *types.Address 3298 if *v == nil { 3299 sv = &types.Address{} 3300 } else { 3301 sv = *v 3302 } 3303 3304 for key, value := range shape { 3305 switch key { 3306 case "AddressId": 3307 if value != nil { 3308 jtv, ok := value.(string) 3309 if !ok { 3310 return fmt.Errorf("expected AddressId to be of type string, got %T instead", value) 3311 } 3312 sv.AddressId = ptr.String(jtv) 3313 } 3314 3315 case "City": 3316 if value != nil { 3317 jtv, ok := value.(string) 3318 if !ok { 3319 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3320 } 3321 sv.City = ptr.String(jtv) 3322 } 3323 3324 case "Company": 3325 if value != nil { 3326 jtv, ok := value.(string) 3327 if !ok { 3328 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3329 } 3330 sv.Company = ptr.String(jtv) 3331 } 3332 3333 case "Country": 3334 if value != nil { 3335 jtv, ok := value.(string) 3336 if !ok { 3337 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3338 } 3339 sv.Country = ptr.String(jtv) 3340 } 3341 3342 case "IsRestricted": 3343 if value != nil { 3344 jtv, ok := value.(bool) 3345 if !ok { 3346 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 3347 } 3348 sv.IsRestricted = jtv 3349 } 3350 3351 case "Landmark": 3352 if value != nil { 3353 jtv, ok := value.(string) 3354 if !ok { 3355 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3356 } 3357 sv.Landmark = ptr.String(jtv) 3358 } 3359 3360 case "Name": 3361 if value != nil { 3362 jtv, ok := value.(string) 3363 if !ok { 3364 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3365 } 3366 sv.Name = ptr.String(jtv) 3367 } 3368 3369 case "PhoneNumber": 3370 if value != nil { 3371 jtv, ok := value.(string) 3372 if !ok { 3373 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3374 } 3375 sv.PhoneNumber = ptr.String(jtv) 3376 } 3377 3378 case "PostalCode": 3379 if value != nil { 3380 jtv, ok := value.(string) 3381 if !ok { 3382 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3383 } 3384 sv.PostalCode = ptr.String(jtv) 3385 } 3386 3387 case "PrefectureOrDistrict": 3388 if value != nil { 3389 jtv, ok := value.(string) 3390 if !ok { 3391 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3392 } 3393 sv.PrefectureOrDistrict = ptr.String(jtv) 3394 } 3395 3396 case "StateOrProvince": 3397 if value != nil { 3398 jtv, ok := value.(string) 3399 if !ok { 3400 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3401 } 3402 sv.StateOrProvince = ptr.String(jtv) 3403 } 3404 3405 case "Street1": 3406 if value != nil { 3407 jtv, ok := value.(string) 3408 if !ok { 3409 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3410 } 3411 sv.Street1 = ptr.String(jtv) 3412 } 3413 3414 case "Street2": 3415 if value != nil { 3416 jtv, ok := value.(string) 3417 if !ok { 3418 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3419 } 3420 sv.Street2 = ptr.String(jtv) 3421 } 3422 3423 case "Street3": 3424 if value != nil { 3425 jtv, ok := value.(string) 3426 if !ok { 3427 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3428 } 3429 sv.Street3 = ptr.String(jtv) 3430 } 3431 3432 default: 3433 _, _ = key, value 3434 3435 } 3436 } 3437 *v = sv 3438 return nil 3439} 3440 3441func awsAwsjson11_deserializeDocumentAddressList(v *[]types.Address, value interface{}) error { 3442 if v == nil { 3443 return fmt.Errorf("unexpected nil of type %T", v) 3444 } 3445 if value == nil { 3446 return nil 3447 } 3448 3449 shape, ok := value.([]interface{}) 3450 if !ok { 3451 return fmt.Errorf("unexpected JSON type %v", value) 3452 } 3453 3454 var cv []types.Address 3455 if *v == nil { 3456 cv = []types.Address{} 3457 } else { 3458 cv = *v 3459 } 3460 3461 for _, value := range shape { 3462 var col types.Address 3463 destAddr := &col 3464 if err := awsAwsjson11_deserializeDocumentAddress(&destAddr, value); err != nil { 3465 return err 3466 } 3467 col = *destAddr 3468 cv = append(cv, col) 3469 3470 } 3471 *v = cv 3472 return nil 3473} 3474 3475func awsAwsjson11_deserializeDocumentClusterLimitExceededException(v **types.ClusterLimitExceededException, value interface{}) error { 3476 if v == nil { 3477 return fmt.Errorf("unexpected nil of type %T", v) 3478 } 3479 if value == nil { 3480 return nil 3481 } 3482 3483 shape, ok := value.(map[string]interface{}) 3484 if !ok { 3485 return fmt.Errorf("unexpected JSON type %v", value) 3486 } 3487 3488 var sv *types.ClusterLimitExceededException 3489 if *v == nil { 3490 sv = &types.ClusterLimitExceededException{} 3491 } else { 3492 sv = *v 3493 } 3494 3495 for key, value := range shape { 3496 switch key { 3497 case "Message": 3498 if value != nil { 3499 jtv, ok := value.(string) 3500 if !ok { 3501 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3502 } 3503 sv.Message = ptr.String(jtv) 3504 } 3505 3506 default: 3507 _, _ = key, value 3508 3509 } 3510 } 3511 *v = sv 3512 return nil 3513} 3514 3515func awsAwsjson11_deserializeDocumentClusterListEntry(v **types.ClusterListEntry, value interface{}) error { 3516 if v == nil { 3517 return fmt.Errorf("unexpected nil of type %T", v) 3518 } 3519 if value == nil { 3520 return nil 3521 } 3522 3523 shape, ok := value.(map[string]interface{}) 3524 if !ok { 3525 return fmt.Errorf("unexpected JSON type %v", value) 3526 } 3527 3528 var sv *types.ClusterListEntry 3529 if *v == nil { 3530 sv = &types.ClusterListEntry{} 3531 } else { 3532 sv = *v 3533 } 3534 3535 for key, value := range shape { 3536 switch key { 3537 case "ClusterId": 3538 if value != nil { 3539 jtv, ok := value.(string) 3540 if !ok { 3541 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3542 } 3543 sv.ClusterId = ptr.String(jtv) 3544 } 3545 3546 case "ClusterState": 3547 if value != nil { 3548 jtv, ok := value.(string) 3549 if !ok { 3550 return fmt.Errorf("expected ClusterState to be of type string, got %T instead", value) 3551 } 3552 sv.ClusterState = types.ClusterState(jtv) 3553 } 3554 3555 case "CreationDate": 3556 if value != nil { 3557 jtv, ok := value.(json.Number) 3558 if !ok { 3559 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 3560 } 3561 f64, err := jtv.Float64() 3562 if err != nil { 3563 return err 3564 } 3565 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3566 } 3567 3568 case "Description": 3569 if value != nil { 3570 jtv, ok := value.(string) 3571 if !ok { 3572 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3573 } 3574 sv.Description = ptr.String(jtv) 3575 } 3576 3577 default: 3578 _, _ = key, value 3579 3580 } 3581 } 3582 *v = sv 3583 return nil 3584} 3585 3586func awsAwsjson11_deserializeDocumentClusterListEntryList(v *[]types.ClusterListEntry, value interface{}) error { 3587 if v == nil { 3588 return fmt.Errorf("unexpected nil of type %T", v) 3589 } 3590 if value == nil { 3591 return nil 3592 } 3593 3594 shape, ok := value.([]interface{}) 3595 if !ok { 3596 return fmt.Errorf("unexpected JSON type %v", value) 3597 } 3598 3599 var cv []types.ClusterListEntry 3600 if *v == nil { 3601 cv = []types.ClusterListEntry{} 3602 } else { 3603 cv = *v 3604 } 3605 3606 for _, value := range shape { 3607 var col types.ClusterListEntry 3608 destAddr := &col 3609 if err := awsAwsjson11_deserializeDocumentClusterListEntry(&destAddr, value); err != nil { 3610 return err 3611 } 3612 col = *destAddr 3613 cv = append(cv, col) 3614 3615 } 3616 *v = cv 3617 return nil 3618} 3619 3620func awsAwsjson11_deserializeDocumentClusterMetadata(v **types.ClusterMetadata, value interface{}) error { 3621 if v == nil { 3622 return fmt.Errorf("unexpected nil of type %T", v) 3623 } 3624 if value == nil { 3625 return nil 3626 } 3627 3628 shape, ok := value.(map[string]interface{}) 3629 if !ok { 3630 return fmt.Errorf("unexpected JSON type %v", value) 3631 } 3632 3633 var sv *types.ClusterMetadata 3634 if *v == nil { 3635 sv = &types.ClusterMetadata{} 3636 } else { 3637 sv = *v 3638 } 3639 3640 for key, value := range shape { 3641 switch key { 3642 case "AddressId": 3643 if value != nil { 3644 jtv, ok := value.(string) 3645 if !ok { 3646 return fmt.Errorf("expected AddressId to be of type string, got %T instead", value) 3647 } 3648 sv.AddressId = ptr.String(jtv) 3649 } 3650 3651 case "ClusterId": 3652 if value != nil { 3653 jtv, ok := value.(string) 3654 if !ok { 3655 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3656 } 3657 sv.ClusterId = ptr.String(jtv) 3658 } 3659 3660 case "ClusterState": 3661 if value != nil { 3662 jtv, ok := value.(string) 3663 if !ok { 3664 return fmt.Errorf("expected ClusterState to be of type string, got %T instead", value) 3665 } 3666 sv.ClusterState = types.ClusterState(jtv) 3667 } 3668 3669 case "CreationDate": 3670 if value != nil { 3671 jtv, ok := value.(json.Number) 3672 if !ok { 3673 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 3674 } 3675 f64, err := jtv.Float64() 3676 if err != nil { 3677 return err 3678 } 3679 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3680 } 3681 3682 case "Description": 3683 if value != nil { 3684 jtv, ok := value.(string) 3685 if !ok { 3686 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3687 } 3688 sv.Description = ptr.String(jtv) 3689 } 3690 3691 case "ForwardingAddressId": 3692 if value != nil { 3693 jtv, ok := value.(string) 3694 if !ok { 3695 return fmt.Errorf("expected AddressId to be of type string, got %T instead", value) 3696 } 3697 sv.ForwardingAddressId = ptr.String(jtv) 3698 } 3699 3700 case "JobType": 3701 if value != nil { 3702 jtv, ok := value.(string) 3703 if !ok { 3704 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 3705 } 3706 sv.JobType = types.JobType(jtv) 3707 } 3708 3709 case "KmsKeyARN": 3710 if value != nil { 3711 jtv, ok := value.(string) 3712 if !ok { 3713 return fmt.Errorf("expected KmsKeyARN to be of type string, got %T instead", value) 3714 } 3715 sv.KmsKeyARN = ptr.String(jtv) 3716 } 3717 3718 case "Notification": 3719 if err := awsAwsjson11_deserializeDocumentNotification(&sv.Notification, value); err != nil { 3720 return err 3721 } 3722 3723 case "Resources": 3724 if err := awsAwsjson11_deserializeDocumentJobResource(&sv.Resources, value); err != nil { 3725 return err 3726 } 3727 3728 case "RoleARN": 3729 if value != nil { 3730 jtv, ok := value.(string) 3731 if !ok { 3732 return fmt.Errorf("expected RoleARN to be of type string, got %T instead", value) 3733 } 3734 sv.RoleARN = ptr.String(jtv) 3735 } 3736 3737 case "ShippingOption": 3738 if value != nil { 3739 jtv, ok := value.(string) 3740 if !ok { 3741 return fmt.Errorf("expected ShippingOption to be of type string, got %T instead", value) 3742 } 3743 sv.ShippingOption = types.ShippingOption(jtv) 3744 } 3745 3746 case "SnowballType": 3747 if value != nil { 3748 jtv, ok := value.(string) 3749 if !ok { 3750 return fmt.Errorf("expected SnowballType to be of type string, got %T instead", value) 3751 } 3752 sv.SnowballType = types.SnowballType(jtv) 3753 } 3754 3755 case "TaxDocuments": 3756 if err := awsAwsjson11_deserializeDocumentTaxDocuments(&sv.TaxDocuments, value); err != nil { 3757 return err 3758 } 3759 3760 default: 3761 _, _ = key, value 3762 3763 } 3764 } 3765 *v = sv 3766 return nil 3767} 3768 3769func awsAwsjson11_deserializeDocumentCompatibleImage(v **types.CompatibleImage, value interface{}) error { 3770 if v == nil { 3771 return fmt.Errorf("unexpected nil of type %T", v) 3772 } 3773 if value == nil { 3774 return nil 3775 } 3776 3777 shape, ok := value.(map[string]interface{}) 3778 if !ok { 3779 return fmt.Errorf("unexpected JSON type %v", value) 3780 } 3781 3782 var sv *types.CompatibleImage 3783 if *v == nil { 3784 sv = &types.CompatibleImage{} 3785 } else { 3786 sv = *v 3787 } 3788 3789 for key, value := range shape { 3790 switch key { 3791 case "AmiId": 3792 if value != nil { 3793 jtv, ok := value.(string) 3794 if !ok { 3795 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3796 } 3797 sv.AmiId = ptr.String(jtv) 3798 } 3799 3800 case "Name": 3801 if value != nil { 3802 jtv, ok := value.(string) 3803 if !ok { 3804 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3805 } 3806 sv.Name = ptr.String(jtv) 3807 } 3808 3809 default: 3810 _, _ = key, value 3811 3812 } 3813 } 3814 *v = sv 3815 return nil 3816} 3817 3818func awsAwsjson11_deserializeDocumentCompatibleImageList(v *[]types.CompatibleImage, value interface{}) error { 3819 if v == nil { 3820 return fmt.Errorf("unexpected nil of type %T", v) 3821 } 3822 if value == nil { 3823 return nil 3824 } 3825 3826 shape, ok := value.([]interface{}) 3827 if !ok { 3828 return fmt.Errorf("unexpected JSON type %v", value) 3829 } 3830 3831 var cv []types.CompatibleImage 3832 if *v == nil { 3833 cv = []types.CompatibleImage{} 3834 } else { 3835 cv = *v 3836 } 3837 3838 for _, value := range shape { 3839 var col types.CompatibleImage 3840 destAddr := &col 3841 if err := awsAwsjson11_deserializeDocumentCompatibleImage(&destAddr, value); err != nil { 3842 return err 3843 } 3844 col = *destAddr 3845 cv = append(cv, col) 3846 3847 } 3848 *v = cv 3849 return nil 3850} 3851 3852func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 3853 if v == nil { 3854 return fmt.Errorf("unexpected nil of type %T", v) 3855 } 3856 if value == nil { 3857 return nil 3858 } 3859 3860 shape, ok := value.(map[string]interface{}) 3861 if !ok { 3862 return fmt.Errorf("unexpected JSON type %v", value) 3863 } 3864 3865 var sv *types.ConflictException 3866 if *v == nil { 3867 sv = &types.ConflictException{} 3868 } else { 3869 sv = *v 3870 } 3871 3872 for key, value := range shape { 3873 switch key { 3874 case "ConflictResource": 3875 if value != nil { 3876 jtv, ok := value.(string) 3877 if !ok { 3878 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3879 } 3880 sv.ConflictResource = ptr.String(jtv) 3881 } 3882 3883 case "Message": 3884 if value != nil { 3885 jtv, ok := value.(string) 3886 if !ok { 3887 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3888 } 3889 sv.Message = ptr.String(jtv) 3890 } 3891 3892 default: 3893 _, _ = key, value 3894 3895 } 3896 } 3897 *v = sv 3898 return nil 3899} 3900 3901func awsAwsjson11_deserializeDocumentDataTransfer(v **types.DataTransfer, value interface{}) error { 3902 if v == nil { 3903 return fmt.Errorf("unexpected nil of type %T", v) 3904 } 3905 if value == nil { 3906 return nil 3907 } 3908 3909 shape, ok := value.(map[string]interface{}) 3910 if !ok { 3911 return fmt.Errorf("unexpected JSON type %v", value) 3912 } 3913 3914 var sv *types.DataTransfer 3915 if *v == nil { 3916 sv = &types.DataTransfer{} 3917 } else { 3918 sv = *v 3919 } 3920 3921 for key, value := range shape { 3922 switch key { 3923 case "BytesTransferred": 3924 if value != nil { 3925 jtv, ok := value.(json.Number) 3926 if !ok { 3927 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 3928 } 3929 i64, err := jtv.Int64() 3930 if err != nil { 3931 return err 3932 } 3933 sv.BytesTransferred = i64 3934 } 3935 3936 case "ObjectsTransferred": 3937 if value != nil { 3938 jtv, ok := value.(json.Number) 3939 if !ok { 3940 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 3941 } 3942 i64, err := jtv.Int64() 3943 if err != nil { 3944 return err 3945 } 3946 sv.ObjectsTransferred = i64 3947 } 3948 3949 case "TotalBytes": 3950 if value != nil { 3951 jtv, ok := value.(json.Number) 3952 if !ok { 3953 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 3954 } 3955 i64, err := jtv.Int64() 3956 if err != nil { 3957 return err 3958 } 3959 sv.TotalBytes = i64 3960 } 3961 3962 case "TotalObjects": 3963 if value != nil { 3964 jtv, ok := value.(json.Number) 3965 if !ok { 3966 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 3967 } 3968 i64, err := jtv.Int64() 3969 if err != nil { 3970 return err 3971 } 3972 sv.TotalObjects = i64 3973 } 3974 3975 default: 3976 _, _ = key, value 3977 3978 } 3979 } 3980 *v = sv 3981 return nil 3982} 3983 3984func awsAwsjson11_deserializeDocumentDeviceConfiguration(v **types.DeviceConfiguration, value interface{}) error { 3985 if v == nil { 3986 return fmt.Errorf("unexpected nil of type %T", v) 3987 } 3988 if value == nil { 3989 return nil 3990 } 3991 3992 shape, ok := value.(map[string]interface{}) 3993 if !ok { 3994 return fmt.Errorf("unexpected JSON type %v", value) 3995 } 3996 3997 var sv *types.DeviceConfiguration 3998 if *v == nil { 3999 sv = &types.DeviceConfiguration{} 4000 } else { 4001 sv = *v 4002 } 4003 4004 for key, value := range shape { 4005 switch key { 4006 case "SnowconeDeviceConfiguration": 4007 if err := awsAwsjson11_deserializeDocumentSnowconeDeviceConfiguration(&sv.SnowconeDeviceConfiguration, value); err != nil { 4008 return err 4009 } 4010 4011 default: 4012 _, _ = key, value 4013 4014 } 4015 } 4016 *v = sv 4017 return nil 4018} 4019 4020func awsAwsjson11_deserializeDocumentEc2AmiResource(v **types.Ec2AmiResource, value interface{}) error { 4021 if v == nil { 4022 return fmt.Errorf("unexpected nil of type %T", v) 4023 } 4024 if value == nil { 4025 return nil 4026 } 4027 4028 shape, ok := value.(map[string]interface{}) 4029 if !ok { 4030 return fmt.Errorf("unexpected JSON type %v", value) 4031 } 4032 4033 var sv *types.Ec2AmiResource 4034 if *v == nil { 4035 sv = &types.Ec2AmiResource{} 4036 } else { 4037 sv = *v 4038 } 4039 4040 for key, value := range shape { 4041 switch key { 4042 case "AmiId": 4043 if value != nil { 4044 jtv, ok := value.(string) 4045 if !ok { 4046 return fmt.Errorf("expected AmiId to be of type string, got %T instead", value) 4047 } 4048 sv.AmiId = ptr.String(jtv) 4049 } 4050 4051 case "SnowballAmiId": 4052 if value != nil { 4053 jtv, ok := value.(string) 4054 if !ok { 4055 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4056 } 4057 sv.SnowballAmiId = ptr.String(jtv) 4058 } 4059 4060 default: 4061 _, _ = key, value 4062 4063 } 4064 } 4065 *v = sv 4066 return nil 4067} 4068 4069func awsAwsjson11_deserializeDocumentEc2AmiResourceList(v *[]types.Ec2AmiResource, value interface{}) error { 4070 if v == nil { 4071 return fmt.Errorf("unexpected nil of type %T", v) 4072 } 4073 if value == nil { 4074 return nil 4075 } 4076 4077 shape, ok := value.([]interface{}) 4078 if !ok { 4079 return fmt.Errorf("unexpected JSON type %v", value) 4080 } 4081 4082 var cv []types.Ec2AmiResource 4083 if *v == nil { 4084 cv = []types.Ec2AmiResource{} 4085 } else { 4086 cv = *v 4087 } 4088 4089 for _, value := range shape { 4090 var col types.Ec2AmiResource 4091 destAddr := &col 4092 if err := awsAwsjson11_deserializeDocumentEc2AmiResource(&destAddr, value); err != nil { 4093 return err 4094 } 4095 col = *destAddr 4096 cv = append(cv, col) 4097 4098 } 4099 *v = cv 4100 return nil 4101} 4102 4103func awsAwsjson11_deserializeDocumentEc2RequestFailedException(v **types.Ec2RequestFailedException, value interface{}) error { 4104 if v == nil { 4105 return fmt.Errorf("unexpected nil of type %T", v) 4106 } 4107 if value == nil { 4108 return nil 4109 } 4110 4111 shape, ok := value.(map[string]interface{}) 4112 if !ok { 4113 return fmt.Errorf("unexpected JSON type %v", value) 4114 } 4115 4116 var sv *types.Ec2RequestFailedException 4117 if *v == nil { 4118 sv = &types.Ec2RequestFailedException{} 4119 } else { 4120 sv = *v 4121 } 4122 4123 for key, value := range shape { 4124 switch key { 4125 case "Message": 4126 if value != nil { 4127 jtv, ok := value.(string) 4128 if !ok { 4129 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4130 } 4131 sv.Message = ptr.String(jtv) 4132 } 4133 4134 default: 4135 _, _ = key, value 4136 4137 } 4138 } 4139 *v = sv 4140 return nil 4141} 4142 4143func awsAwsjson11_deserializeDocumentEventTriggerDefinition(v **types.EventTriggerDefinition, value interface{}) error { 4144 if v == nil { 4145 return fmt.Errorf("unexpected nil of type %T", v) 4146 } 4147 if value == nil { 4148 return nil 4149 } 4150 4151 shape, ok := value.(map[string]interface{}) 4152 if !ok { 4153 return fmt.Errorf("unexpected JSON type %v", value) 4154 } 4155 4156 var sv *types.EventTriggerDefinition 4157 if *v == nil { 4158 sv = &types.EventTriggerDefinition{} 4159 } else { 4160 sv = *v 4161 } 4162 4163 for key, value := range shape { 4164 switch key { 4165 case "EventResourceARN": 4166 if value != nil { 4167 jtv, ok := value.(string) 4168 if !ok { 4169 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 4170 } 4171 sv.EventResourceARN = ptr.String(jtv) 4172 } 4173 4174 default: 4175 _, _ = key, value 4176 4177 } 4178 } 4179 *v = sv 4180 return nil 4181} 4182 4183func awsAwsjson11_deserializeDocumentEventTriggerDefinitionList(v *[]types.EventTriggerDefinition, value interface{}) error { 4184 if v == nil { 4185 return fmt.Errorf("unexpected nil of type %T", v) 4186 } 4187 if value == nil { 4188 return nil 4189 } 4190 4191 shape, ok := value.([]interface{}) 4192 if !ok { 4193 return fmt.Errorf("unexpected JSON type %v", value) 4194 } 4195 4196 var cv []types.EventTriggerDefinition 4197 if *v == nil { 4198 cv = []types.EventTriggerDefinition{} 4199 } else { 4200 cv = *v 4201 } 4202 4203 for _, value := range shape { 4204 var col types.EventTriggerDefinition 4205 destAddr := &col 4206 if err := awsAwsjson11_deserializeDocumentEventTriggerDefinition(&destAddr, value); err != nil { 4207 return err 4208 } 4209 col = *destAddr 4210 cv = append(cv, col) 4211 4212 } 4213 *v = cv 4214 return nil 4215} 4216 4217func awsAwsjson11_deserializeDocumentINDTaxDocuments(v **types.INDTaxDocuments, value interface{}) error { 4218 if v == nil { 4219 return fmt.Errorf("unexpected nil of type %T", v) 4220 } 4221 if value == nil { 4222 return nil 4223 } 4224 4225 shape, ok := value.(map[string]interface{}) 4226 if !ok { 4227 return fmt.Errorf("unexpected JSON type %v", value) 4228 } 4229 4230 var sv *types.INDTaxDocuments 4231 if *v == nil { 4232 sv = &types.INDTaxDocuments{} 4233 } else { 4234 sv = *v 4235 } 4236 4237 for key, value := range shape { 4238 switch key { 4239 case "GSTIN": 4240 if value != nil { 4241 jtv, ok := value.(string) 4242 if !ok { 4243 return fmt.Errorf("expected GSTIN to be of type string, got %T instead", value) 4244 } 4245 sv.GSTIN = ptr.String(jtv) 4246 } 4247 4248 default: 4249 _, _ = key, value 4250 4251 } 4252 } 4253 *v = sv 4254 return nil 4255} 4256 4257func awsAwsjson11_deserializeDocumentInvalidAddressException(v **types.InvalidAddressException, value interface{}) error { 4258 if v == nil { 4259 return fmt.Errorf("unexpected nil of type %T", v) 4260 } 4261 if value == nil { 4262 return nil 4263 } 4264 4265 shape, ok := value.(map[string]interface{}) 4266 if !ok { 4267 return fmt.Errorf("unexpected JSON type %v", value) 4268 } 4269 4270 var sv *types.InvalidAddressException 4271 if *v == nil { 4272 sv = &types.InvalidAddressException{} 4273 } else { 4274 sv = *v 4275 } 4276 4277 for key, value := range shape { 4278 switch key { 4279 case "Message": 4280 if value != nil { 4281 jtv, ok := value.(string) 4282 if !ok { 4283 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4284 } 4285 sv.Message = ptr.String(jtv) 4286 } 4287 4288 default: 4289 _, _ = key, value 4290 4291 } 4292 } 4293 *v = sv 4294 return nil 4295} 4296 4297func awsAwsjson11_deserializeDocumentInvalidInputCombinationException(v **types.InvalidInputCombinationException, value interface{}) error { 4298 if v == nil { 4299 return fmt.Errorf("unexpected nil of type %T", v) 4300 } 4301 if value == nil { 4302 return nil 4303 } 4304 4305 shape, ok := value.(map[string]interface{}) 4306 if !ok { 4307 return fmt.Errorf("unexpected JSON type %v", value) 4308 } 4309 4310 var sv *types.InvalidInputCombinationException 4311 if *v == nil { 4312 sv = &types.InvalidInputCombinationException{} 4313 } else { 4314 sv = *v 4315 } 4316 4317 for key, value := range shape { 4318 switch key { 4319 case "Message": 4320 if value != nil { 4321 jtv, ok := value.(string) 4322 if !ok { 4323 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4324 } 4325 sv.Message = ptr.String(jtv) 4326 } 4327 4328 default: 4329 _, _ = key, value 4330 4331 } 4332 } 4333 *v = sv 4334 return nil 4335} 4336 4337func awsAwsjson11_deserializeDocumentInvalidJobStateException(v **types.InvalidJobStateException, value interface{}) error { 4338 if v == nil { 4339 return fmt.Errorf("unexpected nil of type %T", v) 4340 } 4341 if value == nil { 4342 return nil 4343 } 4344 4345 shape, ok := value.(map[string]interface{}) 4346 if !ok { 4347 return fmt.Errorf("unexpected JSON type %v", value) 4348 } 4349 4350 var sv *types.InvalidJobStateException 4351 if *v == nil { 4352 sv = &types.InvalidJobStateException{} 4353 } else { 4354 sv = *v 4355 } 4356 4357 for key, value := range shape { 4358 switch key { 4359 case "Message": 4360 if value != nil { 4361 jtv, ok := value.(string) 4362 if !ok { 4363 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4364 } 4365 sv.Message = ptr.String(jtv) 4366 } 4367 4368 default: 4369 _, _ = key, value 4370 4371 } 4372 } 4373 *v = sv 4374 return nil 4375} 4376 4377func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 4378 if v == nil { 4379 return fmt.Errorf("unexpected nil of type %T", v) 4380 } 4381 if value == nil { 4382 return nil 4383 } 4384 4385 shape, ok := value.(map[string]interface{}) 4386 if !ok { 4387 return fmt.Errorf("unexpected JSON type %v", value) 4388 } 4389 4390 var sv *types.InvalidNextTokenException 4391 if *v == nil { 4392 sv = &types.InvalidNextTokenException{} 4393 } else { 4394 sv = *v 4395 } 4396 4397 for key, value := range shape { 4398 switch key { 4399 case "Message": 4400 if value != nil { 4401 jtv, ok := value.(string) 4402 if !ok { 4403 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4404 } 4405 sv.Message = ptr.String(jtv) 4406 } 4407 4408 default: 4409 _, _ = key, value 4410 4411 } 4412 } 4413 *v = sv 4414 return nil 4415} 4416 4417func awsAwsjson11_deserializeDocumentInvalidResourceException(v **types.InvalidResourceException, value interface{}) error { 4418 if v == nil { 4419 return fmt.Errorf("unexpected nil of type %T", v) 4420 } 4421 if value == nil { 4422 return nil 4423 } 4424 4425 shape, ok := value.(map[string]interface{}) 4426 if !ok { 4427 return fmt.Errorf("unexpected JSON type %v", value) 4428 } 4429 4430 var sv *types.InvalidResourceException 4431 if *v == nil { 4432 sv = &types.InvalidResourceException{} 4433 } else { 4434 sv = *v 4435 } 4436 4437 for key, value := range shape { 4438 switch key { 4439 case "Message": 4440 if value != nil { 4441 jtv, ok := value.(string) 4442 if !ok { 4443 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4444 } 4445 sv.Message = ptr.String(jtv) 4446 } 4447 4448 case "ResourceType": 4449 if value != nil { 4450 jtv, ok := value.(string) 4451 if !ok { 4452 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4453 } 4454 sv.ResourceType = ptr.String(jtv) 4455 } 4456 4457 default: 4458 _, _ = key, value 4459 4460 } 4461 } 4462 *v = sv 4463 return nil 4464} 4465 4466func awsAwsjson11_deserializeDocumentJobListEntry(v **types.JobListEntry, value interface{}) error { 4467 if v == nil { 4468 return fmt.Errorf("unexpected nil of type %T", v) 4469 } 4470 if value == nil { 4471 return nil 4472 } 4473 4474 shape, ok := value.(map[string]interface{}) 4475 if !ok { 4476 return fmt.Errorf("unexpected JSON type %v", value) 4477 } 4478 4479 var sv *types.JobListEntry 4480 if *v == nil { 4481 sv = &types.JobListEntry{} 4482 } else { 4483 sv = *v 4484 } 4485 4486 for key, value := range shape { 4487 switch key { 4488 case "CreationDate": 4489 if value != nil { 4490 jtv, ok := value.(json.Number) 4491 if !ok { 4492 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4493 } 4494 f64, err := jtv.Float64() 4495 if err != nil { 4496 return err 4497 } 4498 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4499 } 4500 4501 case "Description": 4502 if value != nil { 4503 jtv, ok := value.(string) 4504 if !ok { 4505 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4506 } 4507 sv.Description = ptr.String(jtv) 4508 } 4509 4510 case "IsMaster": 4511 if value != nil { 4512 jtv, ok := value.(bool) 4513 if !ok { 4514 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4515 } 4516 sv.IsMaster = jtv 4517 } 4518 4519 case "JobId": 4520 if value != nil { 4521 jtv, ok := value.(string) 4522 if !ok { 4523 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4524 } 4525 sv.JobId = ptr.String(jtv) 4526 } 4527 4528 case "JobState": 4529 if value != nil { 4530 jtv, ok := value.(string) 4531 if !ok { 4532 return fmt.Errorf("expected JobState to be of type string, got %T instead", value) 4533 } 4534 sv.JobState = types.JobState(jtv) 4535 } 4536 4537 case "JobType": 4538 if value != nil { 4539 jtv, ok := value.(string) 4540 if !ok { 4541 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 4542 } 4543 sv.JobType = types.JobType(jtv) 4544 } 4545 4546 case "SnowballType": 4547 if value != nil { 4548 jtv, ok := value.(string) 4549 if !ok { 4550 return fmt.Errorf("expected SnowballType to be of type string, got %T instead", value) 4551 } 4552 sv.SnowballType = types.SnowballType(jtv) 4553 } 4554 4555 default: 4556 _, _ = key, value 4557 4558 } 4559 } 4560 *v = sv 4561 return nil 4562} 4563 4564func awsAwsjson11_deserializeDocumentJobListEntryList(v *[]types.JobListEntry, value interface{}) error { 4565 if v == nil { 4566 return fmt.Errorf("unexpected nil of type %T", v) 4567 } 4568 if value == nil { 4569 return nil 4570 } 4571 4572 shape, ok := value.([]interface{}) 4573 if !ok { 4574 return fmt.Errorf("unexpected JSON type %v", value) 4575 } 4576 4577 var cv []types.JobListEntry 4578 if *v == nil { 4579 cv = []types.JobListEntry{} 4580 } else { 4581 cv = *v 4582 } 4583 4584 for _, value := range shape { 4585 var col types.JobListEntry 4586 destAddr := &col 4587 if err := awsAwsjson11_deserializeDocumentJobListEntry(&destAddr, value); err != nil { 4588 return err 4589 } 4590 col = *destAddr 4591 cv = append(cv, col) 4592 4593 } 4594 *v = cv 4595 return nil 4596} 4597 4598func awsAwsjson11_deserializeDocumentJobLogs(v **types.JobLogs, value interface{}) error { 4599 if v == nil { 4600 return fmt.Errorf("unexpected nil of type %T", v) 4601 } 4602 if value == nil { 4603 return nil 4604 } 4605 4606 shape, ok := value.(map[string]interface{}) 4607 if !ok { 4608 return fmt.Errorf("unexpected JSON type %v", value) 4609 } 4610 4611 var sv *types.JobLogs 4612 if *v == nil { 4613 sv = &types.JobLogs{} 4614 } else { 4615 sv = *v 4616 } 4617 4618 for key, value := range shape { 4619 switch key { 4620 case "JobCompletionReportURI": 4621 if value != nil { 4622 jtv, ok := value.(string) 4623 if !ok { 4624 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4625 } 4626 sv.JobCompletionReportURI = ptr.String(jtv) 4627 } 4628 4629 case "JobFailureLogURI": 4630 if value != nil { 4631 jtv, ok := value.(string) 4632 if !ok { 4633 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4634 } 4635 sv.JobFailureLogURI = ptr.String(jtv) 4636 } 4637 4638 case "JobSuccessLogURI": 4639 if value != nil { 4640 jtv, ok := value.(string) 4641 if !ok { 4642 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4643 } 4644 sv.JobSuccessLogURI = ptr.String(jtv) 4645 } 4646 4647 default: 4648 _, _ = key, value 4649 4650 } 4651 } 4652 *v = sv 4653 return nil 4654} 4655 4656func awsAwsjson11_deserializeDocumentJobMetadata(v **types.JobMetadata, value interface{}) error { 4657 if v == nil { 4658 return fmt.Errorf("unexpected nil of type %T", v) 4659 } 4660 if value == nil { 4661 return nil 4662 } 4663 4664 shape, ok := value.(map[string]interface{}) 4665 if !ok { 4666 return fmt.Errorf("unexpected JSON type %v", value) 4667 } 4668 4669 var sv *types.JobMetadata 4670 if *v == nil { 4671 sv = &types.JobMetadata{} 4672 } else { 4673 sv = *v 4674 } 4675 4676 for key, value := range shape { 4677 switch key { 4678 case "AddressId": 4679 if value != nil { 4680 jtv, ok := value.(string) 4681 if !ok { 4682 return fmt.Errorf("expected AddressId to be of type string, got %T instead", value) 4683 } 4684 sv.AddressId = ptr.String(jtv) 4685 } 4686 4687 case "ClusterId": 4688 if value != nil { 4689 jtv, ok := value.(string) 4690 if !ok { 4691 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4692 } 4693 sv.ClusterId = ptr.String(jtv) 4694 } 4695 4696 case "CreationDate": 4697 if value != nil { 4698 jtv, ok := value.(json.Number) 4699 if !ok { 4700 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4701 } 4702 f64, err := jtv.Float64() 4703 if err != nil { 4704 return err 4705 } 4706 sv.CreationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4707 } 4708 4709 case "DataTransferProgress": 4710 if err := awsAwsjson11_deserializeDocumentDataTransfer(&sv.DataTransferProgress, value); err != nil { 4711 return err 4712 } 4713 4714 case "Description": 4715 if value != nil { 4716 jtv, ok := value.(string) 4717 if !ok { 4718 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4719 } 4720 sv.Description = ptr.String(jtv) 4721 } 4722 4723 case "DeviceConfiguration": 4724 if err := awsAwsjson11_deserializeDocumentDeviceConfiguration(&sv.DeviceConfiguration, value); err != nil { 4725 return err 4726 } 4727 4728 case "ForwardingAddressId": 4729 if value != nil { 4730 jtv, ok := value.(string) 4731 if !ok { 4732 return fmt.Errorf("expected AddressId to be of type string, got %T instead", value) 4733 } 4734 sv.ForwardingAddressId = ptr.String(jtv) 4735 } 4736 4737 case "JobId": 4738 if value != nil { 4739 jtv, ok := value.(string) 4740 if !ok { 4741 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4742 } 4743 sv.JobId = ptr.String(jtv) 4744 } 4745 4746 case "JobLogInfo": 4747 if err := awsAwsjson11_deserializeDocumentJobLogs(&sv.JobLogInfo, value); err != nil { 4748 return err 4749 } 4750 4751 case "JobState": 4752 if value != nil { 4753 jtv, ok := value.(string) 4754 if !ok { 4755 return fmt.Errorf("expected JobState to be of type string, got %T instead", value) 4756 } 4757 sv.JobState = types.JobState(jtv) 4758 } 4759 4760 case "JobType": 4761 if value != nil { 4762 jtv, ok := value.(string) 4763 if !ok { 4764 return fmt.Errorf("expected JobType to be of type string, got %T instead", value) 4765 } 4766 sv.JobType = types.JobType(jtv) 4767 } 4768 4769 case "KmsKeyARN": 4770 if value != nil { 4771 jtv, ok := value.(string) 4772 if !ok { 4773 return fmt.Errorf("expected KmsKeyARN to be of type string, got %T instead", value) 4774 } 4775 sv.KmsKeyARN = ptr.String(jtv) 4776 } 4777 4778 case "LongTermPricingId": 4779 if value != nil { 4780 jtv, ok := value.(string) 4781 if !ok { 4782 return fmt.Errorf("expected LongTermPricingId to be of type string, got %T instead", value) 4783 } 4784 sv.LongTermPricingId = ptr.String(jtv) 4785 } 4786 4787 case "Notification": 4788 if err := awsAwsjson11_deserializeDocumentNotification(&sv.Notification, value); err != nil { 4789 return err 4790 } 4791 4792 case "Resources": 4793 if err := awsAwsjson11_deserializeDocumentJobResource(&sv.Resources, value); err != nil { 4794 return err 4795 } 4796 4797 case "RoleARN": 4798 if value != nil { 4799 jtv, ok := value.(string) 4800 if !ok { 4801 return fmt.Errorf("expected RoleARN to be of type string, got %T instead", value) 4802 } 4803 sv.RoleARN = ptr.String(jtv) 4804 } 4805 4806 case "ShippingDetails": 4807 if err := awsAwsjson11_deserializeDocumentShippingDetails(&sv.ShippingDetails, value); err != nil { 4808 return err 4809 } 4810 4811 case "SnowballCapacityPreference": 4812 if value != nil { 4813 jtv, ok := value.(string) 4814 if !ok { 4815 return fmt.Errorf("expected SnowballCapacity to be of type string, got %T instead", value) 4816 } 4817 sv.SnowballCapacityPreference = types.SnowballCapacity(jtv) 4818 } 4819 4820 case "SnowballType": 4821 if value != nil { 4822 jtv, ok := value.(string) 4823 if !ok { 4824 return fmt.Errorf("expected SnowballType to be of type string, got %T instead", value) 4825 } 4826 sv.SnowballType = types.SnowballType(jtv) 4827 } 4828 4829 case "TaxDocuments": 4830 if err := awsAwsjson11_deserializeDocumentTaxDocuments(&sv.TaxDocuments, value); err != nil { 4831 return err 4832 } 4833 4834 default: 4835 _, _ = key, value 4836 4837 } 4838 } 4839 *v = sv 4840 return nil 4841} 4842 4843func awsAwsjson11_deserializeDocumentJobMetadataList(v *[]types.JobMetadata, 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.([]interface{}) 4852 if !ok { 4853 return fmt.Errorf("unexpected JSON type %v", value) 4854 } 4855 4856 var cv []types.JobMetadata 4857 if *v == nil { 4858 cv = []types.JobMetadata{} 4859 } else { 4860 cv = *v 4861 } 4862 4863 for _, value := range shape { 4864 var col types.JobMetadata 4865 destAddr := &col 4866 if err := awsAwsjson11_deserializeDocumentJobMetadata(&destAddr, value); err != nil { 4867 return err 4868 } 4869 col = *destAddr 4870 cv = append(cv, col) 4871 4872 } 4873 *v = cv 4874 return nil 4875} 4876 4877func awsAwsjson11_deserializeDocumentJobResource(v **types.JobResource, value interface{}) error { 4878 if v == nil { 4879 return fmt.Errorf("unexpected nil of type %T", v) 4880 } 4881 if value == nil { 4882 return nil 4883 } 4884 4885 shape, ok := value.(map[string]interface{}) 4886 if !ok { 4887 return fmt.Errorf("unexpected JSON type %v", value) 4888 } 4889 4890 var sv *types.JobResource 4891 if *v == nil { 4892 sv = &types.JobResource{} 4893 } else { 4894 sv = *v 4895 } 4896 4897 for key, value := range shape { 4898 switch key { 4899 case "Ec2AmiResources": 4900 if err := awsAwsjson11_deserializeDocumentEc2AmiResourceList(&sv.Ec2AmiResources, value); err != nil { 4901 return err 4902 } 4903 4904 case "LambdaResources": 4905 if err := awsAwsjson11_deserializeDocumentLambdaResourceList(&sv.LambdaResources, value); err != nil { 4906 return err 4907 } 4908 4909 case "S3Resources": 4910 if err := awsAwsjson11_deserializeDocumentS3ResourceList(&sv.S3Resources, value); err != nil { 4911 return err 4912 } 4913 4914 default: 4915 _, _ = key, value 4916 4917 } 4918 } 4919 *v = sv 4920 return nil 4921} 4922 4923func awsAwsjson11_deserializeDocumentJobStateList(v *[]types.JobState, value interface{}) error { 4924 if v == nil { 4925 return fmt.Errorf("unexpected nil of type %T", v) 4926 } 4927 if value == nil { 4928 return nil 4929 } 4930 4931 shape, ok := value.([]interface{}) 4932 if !ok { 4933 return fmt.Errorf("unexpected JSON type %v", value) 4934 } 4935 4936 var cv []types.JobState 4937 if *v == nil { 4938 cv = []types.JobState{} 4939 } else { 4940 cv = *v 4941 } 4942 4943 for _, value := range shape { 4944 var col types.JobState 4945 if value != nil { 4946 jtv, ok := value.(string) 4947 if !ok { 4948 return fmt.Errorf("expected JobState to be of type string, got %T instead", value) 4949 } 4950 col = types.JobState(jtv) 4951 } 4952 cv = append(cv, col) 4953 4954 } 4955 *v = cv 4956 return nil 4957} 4958 4959func awsAwsjson11_deserializeDocumentKeyRange(v **types.KeyRange, value interface{}) error { 4960 if v == nil { 4961 return fmt.Errorf("unexpected nil of type %T", v) 4962 } 4963 if value == nil { 4964 return nil 4965 } 4966 4967 shape, ok := value.(map[string]interface{}) 4968 if !ok { 4969 return fmt.Errorf("unexpected JSON type %v", value) 4970 } 4971 4972 var sv *types.KeyRange 4973 if *v == nil { 4974 sv = &types.KeyRange{} 4975 } else { 4976 sv = *v 4977 } 4978 4979 for key, value := range shape { 4980 switch key { 4981 case "BeginMarker": 4982 if value != nil { 4983 jtv, ok := value.(string) 4984 if !ok { 4985 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4986 } 4987 sv.BeginMarker = ptr.String(jtv) 4988 } 4989 4990 case "EndMarker": 4991 if value != nil { 4992 jtv, ok := value.(string) 4993 if !ok { 4994 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4995 } 4996 sv.EndMarker = ptr.String(jtv) 4997 } 4998 4999 default: 5000 _, _ = key, value 5001 5002 } 5003 } 5004 *v = sv 5005 return nil 5006} 5007 5008func awsAwsjson11_deserializeDocumentKMSRequestFailedException(v **types.KMSRequestFailedException, value interface{}) error { 5009 if v == nil { 5010 return fmt.Errorf("unexpected nil of type %T", v) 5011 } 5012 if value == nil { 5013 return nil 5014 } 5015 5016 shape, ok := value.(map[string]interface{}) 5017 if !ok { 5018 return fmt.Errorf("unexpected JSON type %v", value) 5019 } 5020 5021 var sv *types.KMSRequestFailedException 5022 if *v == nil { 5023 sv = &types.KMSRequestFailedException{} 5024 } else { 5025 sv = *v 5026 } 5027 5028 for key, value := range shape { 5029 switch key { 5030 case "Message": 5031 if value != nil { 5032 jtv, ok := value.(string) 5033 if !ok { 5034 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5035 } 5036 sv.Message = ptr.String(jtv) 5037 } 5038 5039 default: 5040 _, _ = key, value 5041 5042 } 5043 } 5044 *v = sv 5045 return nil 5046} 5047 5048func awsAwsjson11_deserializeDocumentLambdaResource(v **types.LambdaResource, value interface{}) error { 5049 if v == nil { 5050 return fmt.Errorf("unexpected nil of type %T", v) 5051 } 5052 if value == nil { 5053 return nil 5054 } 5055 5056 shape, ok := value.(map[string]interface{}) 5057 if !ok { 5058 return fmt.Errorf("unexpected JSON type %v", value) 5059 } 5060 5061 var sv *types.LambdaResource 5062 if *v == nil { 5063 sv = &types.LambdaResource{} 5064 } else { 5065 sv = *v 5066 } 5067 5068 for key, value := range shape { 5069 switch key { 5070 case "EventTriggers": 5071 if err := awsAwsjson11_deserializeDocumentEventTriggerDefinitionList(&sv.EventTriggers, value); err != nil { 5072 return err 5073 } 5074 5075 case "LambdaArn": 5076 if value != nil { 5077 jtv, ok := value.(string) 5078 if !ok { 5079 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 5080 } 5081 sv.LambdaArn = ptr.String(jtv) 5082 } 5083 5084 default: 5085 _, _ = key, value 5086 5087 } 5088 } 5089 *v = sv 5090 return nil 5091} 5092 5093func awsAwsjson11_deserializeDocumentLambdaResourceList(v *[]types.LambdaResource, value interface{}) error { 5094 if v == nil { 5095 return fmt.Errorf("unexpected nil of type %T", v) 5096 } 5097 if value == nil { 5098 return nil 5099 } 5100 5101 shape, ok := value.([]interface{}) 5102 if !ok { 5103 return fmt.Errorf("unexpected JSON type %v", value) 5104 } 5105 5106 var cv []types.LambdaResource 5107 if *v == nil { 5108 cv = []types.LambdaResource{} 5109 } else { 5110 cv = *v 5111 } 5112 5113 for _, value := range shape { 5114 var col types.LambdaResource 5115 destAddr := &col 5116 if err := awsAwsjson11_deserializeDocumentLambdaResource(&destAddr, value); err != nil { 5117 return err 5118 } 5119 col = *destAddr 5120 cv = append(cv, col) 5121 5122 } 5123 *v = cv 5124 return nil 5125} 5126 5127func awsAwsjson11_deserializeDocumentLongTermPricingAssociatedJobIdList(v *[]string, value interface{}) error { 5128 if v == nil { 5129 return fmt.Errorf("unexpected nil of type %T", v) 5130 } 5131 if value == nil { 5132 return nil 5133 } 5134 5135 shape, ok := value.([]interface{}) 5136 if !ok { 5137 return fmt.Errorf("unexpected JSON type %v", value) 5138 } 5139 5140 var cv []string 5141 if *v == nil { 5142 cv = []string{} 5143 } else { 5144 cv = *v 5145 } 5146 5147 for _, value := range shape { 5148 var col string 5149 if value != nil { 5150 jtv, ok := value.(string) 5151 if !ok { 5152 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 5153 } 5154 col = jtv 5155 } 5156 cv = append(cv, col) 5157 5158 } 5159 *v = cv 5160 return nil 5161} 5162 5163func awsAwsjson11_deserializeDocumentLongTermPricingEntryList(v *[]types.LongTermPricingListEntry, value interface{}) error { 5164 if v == nil { 5165 return fmt.Errorf("unexpected nil of type %T", v) 5166 } 5167 if value == nil { 5168 return nil 5169 } 5170 5171 shape, ok := value.([]interface{}) 5172 if !ok { 5173 return fmt.Errorf("unexpected JSON type %v", value) 5174 } 5175 5176 var cv []types.LongTermPricingListEntry 5177 if *v == nil { 5178 cv = []types.LongTermPricingListEntry{} 5179 } else { 5180 cv = *v 5181 } 5182 5183 for _, value := range shape { 5184 var col types.LongTermPricingListEntry 5185 destAddr := &col 5186 if err := awsAwsjson11_deserializeDocumentLongTermPricingListEntry(&destAddr, value); err != nil { 5187 return err 5188 } 5189 col = *destAddr 5190 cv = append(cv, col) 5191 5192 } 5193 *v = cv 5194 return nil 5195} 5196 5197func awsAwsjson11_deserializeDocumentLongTermPricingListEntry(v **types.LongTermPricingListEntry, value interface{}) error { 5198 if v == nil { 5199 return fmt.Errorf("unexpected nil of type %T", v) 5200 } 5201 if value == nil { 5202 return nil 5203 } 5204 5205 shape, ok := value.(map[string]interface{}) 5206 if !ok { 5207 return fmt.Errorf("unexpected JSON type %v", value) 5208 } 5209 5210 var sv *types.LongTermPricingListEntry 5211 if *v == nil { 5212 sv = &types.LongTermPricingListEntry{} 5213 } else { 5214 sv = *v 5215 } 5216 5217 for key, value := range shape { 5218 switch key { 5219 case "CurrentActiveJob": 5220 if value != nil { 5221 jtv, ok := value.(string) 5222 if !ok { 5223 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 5224 } 5225 sv.CurrentActiveJob = ptr.String(jtv) 5226 } 5227 5228 case "IsLongTermPricingAutoRenew": 5229 if value != nil { 5230 jtv, ok := value.(bool) 5231 if !ok { 5232 return fmt.Errorf("expected JavaBoolean to be of type *bool, got %T instead", value) 5233 } 5234 sv.IsLongTermPricingAutoRenew = ptr.Bool(jtv) 5235 } 5236 5237 case "JobIds": 5238 if err := awsAwsjson11_deserializeDocumentLongTermPricingAssociatedJobIdList(&sv.JobIds, value); err != nil { 5239 return err 5240 } 5241 5242 case "LongTermPricingEndDate": 5243 if value != nil { 5244 jtv, ok := value.(json.Number) 5245 if !ok { 5246 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5247 } 5248 f64, err := jtv.Float64() 5249 if err != nil { 5250 return err 5251 } 5252 sv.LongTermPricingEndDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5253 } 5254 5255 case "LongTermPricingId": 5256 if value != nil { 5257 jtv, ok := value.(string) 5258 if !ok { 5259 return fmt.Errorf("expected LongTermPricingId to be of type string, got %T instead", value) 5260 } 5261 sv.LongTermPricingId = ptr.String(jtv) 5262 } 5263 5264 case "LongTermPricingStartDate": 5265 if value != nil { 5266 jtv, ok := value.(json.Number) 5267 if !ok { 5268 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5269 } 5270 f64, err := jtv.Float64() 5271 if err != nil { 5272 return err 5273 } 5274 sv.LongTermPricingStartDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5275 } 5276 5277 case "LongTermPricingStatus": 5278 if value != nil { 5279 jtv, ok := value.(string) 5280 if !ok { 5281 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5282 } 5283 sv.LongTermPricingStatus = ptr.String(jtv) 5284 } 5285 5286 case "LongTermPricingType": 5287 if value != nil { 5288 jtv, ok := value.(string) 5289 if !ok { 5290 return fmt.Errorf("expected LongTermPricingType to be of type string, got %T instead", value) 5291 } 5292 sv.LongTermPricingType = types.LongTermPricingType(jtv) 5293 } 5294 5295 case "ReplacementJob": 5296 if value != nil { 5297 jtv, ok := value.(string) 5298 if !ok { 5299 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 5300 } 5301 sv.ReplacementJob = ptr.String(jtv) 5302 } 5303 5304 case "SnowballType": 5305 if value != nil { 5306 jtv, ok := value.(string) 5307 if !ok { 5308 return fmt.Errorf("expected SnowballType to be of type string, got %T instead", value) 5309 } 5310 sv.SnowballType = types.SnowballType(jtv) 5311 } 5312 5313 default: 5314 _, _ = key, value 5315 5316 } 5317 } 5318 *v = sv 5319 return nil 5320} 5321 5322func awsAwsjson11_deserializeDocumentNotification(v **types.Notification, value interface{}) error { 5323 if v == nil { 5324 return fmt.Errorf("unexpected nil of type %T", v) 5325 } 5326 if value == nil { 5327 return nil 5328 } 5329 5330 shape, ok := value.(map[string]interface{}) 5331 if !ok { 5332 return fmt.Errorf("unexpected JSON type %v", value) 5333 } 5334 5335 var sv *types.Notification 5336 if *v == nil { 5337 sv = &types.Notification{} 5338 } else { 5339 sv = *v 5340 } 5341 5342 for key, value := range shape { 5343 switch key { 5344 case "JobStatesToNotify": 5345 if err := awsAwsjson11_deserializeDocumentJobStateList(&sv.JobStatesToNotify, value); err != nil { 5346 return err 5347 } 5348 5349 case "NotifyAll": 5350 if value != nil { 5351 jtv, ok := value.(bool) 5352 if !ok { 5353 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5354 } 5355 sv.NotifyAll = jtv 5356 } 5357 5358 case "SnsTopicARN": 5359 if value != nil { 5360 jtv, ok := value.(string) 5361 if !ok { 5362 return fmt.Errorf("expected SnsTopicARN to be of type string, got %T instead", value) 5363 } 5364 sv.SnsTopicARN = ptr.String(jtv) 5365 } 5366 5367 default: 5368 _, _ = key, value 5369 5370 } 5371 } 5372 *v = sv 5373 return nil 5374} 5375 5376func awsAwsjson11_deserializeDocumentReturnShippingLabelAlreadyExistsException(v **types.ReturnShippingLabelAlreadyExistsException, value interface{}) error { 5377 if v == nil { 5378 return fmt.Errorf("unexpected nil of type %T", v) 5379 } 5380 if value == nil { 5381 return nil 5382 } 5383 5384 shape, ok := value.(map[string]interface{}) 5385 if !ok { 5386 return fmt.Errorf("unexpected JSON type %v", value) 5387 } 5388 5389 var sv *types.ReturnShippingLabelAlreadyExistsException 5390 if *v == nil { 5391 sv = &types.ReturnShippingLabelAlreadyExistsException{} 5392 } else { 5393 sv = *v 5394 } 5395 5396 for key, value := range shape { 5397 switch key { 5398 case "Message": 5399 if value != nil { 5400 jtv, ok := value.(string) 5401 if !ok { 5402 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5403 } 5404 sv.Message = ptr.String(jtv) 5405 } 5406 5407 default: 5408 _, _ = key, value 5409 5410 } 5411 } 5412 *v = sv 5413 return nil 5414} 5415 5416func awsAwsjson11_deserializeDocumentS3Resource(v **types.S3Resource, value interface{}) error { 5417 if v == nil { 5418 return fmt.Errorf("unexpected nil of type %T", v) 5419 } 5420 if value == nil { 5421 return nil 5422 } 5423 5424 shape, ok := value.(map[string]interface{}) 5425 if !ok { 5426 return fmt.Errorf("unexpected JSON type %v", value) 5427 } 5428 5429 var sv *types.S3Resource 5430 if *v == nil { 5431 sv = &types.S3Resource{} 5432 } else { 5433 sv = *v 5434 } 5435 5436 for key, value := range shape { 5437 switch key { 5438 case "BucketArn": 5439 if value != nil { 5440 jtv, ok := value.(string) 5441 if !ok { 5442 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 5443 } 5444 sv.BucketArn = ptr.String(jtv) 5445 } 5446 5447 case "KeyRange": 5448 if err := awsAwsjson11_deserializeDocumentKeyRange(&sv.KeyRange, value); err != nil { 5449 return err 5450 } 5451 5452 default: 5453 _, _ = key, value 5454 5455 } 5456 } 5457 *v = sv 5458 return nil 5459} 5460 5461func awsAwsjson11_deserializeDocumentS3ResourceList(v *[]types.S3Resource, value interface{}) error { 5462 if v == nil { 5463 return fmt.Errorf("unexpected nil of type %T", v) 5464 } 5465 if value == nil { 5466 return nil 5467 } 5468 5469 shape, ok := value.([]interface{}) 5470 if !ok { 5471 return fmt.Errorf("unexpected JSON type %v", value) 5472 } 5473 5474 var cv []types.S3Resource 5475 if *v == nil { 5476 cv = []types.S3Resource{} 5477 } else { 5478 cv = *v 5479 } 5480 5481 for _, value := range shape { 5482 var col types.S3Resource 5483 destAddr := &col 5484 if err := awsAwsjson11_deserializeDocumentS3Resource(&destAddr, value); err != nil { 5485 return err 5486 } 5487 col = *destAddr 5488 cv = append(cv, col) 5489 5490 } 5491 *v = cv 5492 return nil 5493} 5494 5495func awsAwsjson11_deserializeDocumentShipment(v **types.Shipment, value interface{}) error { 5496 if v == nil { 5497 return fmt.Errorf("unexpected nil of type %T", v) 5498 } 5499 if value == nil { 5500 return nil 5501 } 5502 5503 shape, ok := value.(map[string]interface{}) 5504 if !ok { 5505 return fmt.Errorf("unexpected JSON type %v", value) 5506 } 5507 5508 var sv *types.Shipment 5509 if *v == nil { 5510 sv = &types.Shipment{} 5511 } else { 5512 sv = *v 5513 } 5514 5515 for key, value := range shape { 5516 switch key { 5517 case "Status": 5518 if value != nil { 5519 jtv, ok := value.(string) 5520 if !ok { 5521 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5522 } 5523 sv.Status = ptr.String(jtv) 5524 } 5525 5526 case "TrackingNumber": 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.TrackingNumber = ptr.String(jtv) 5533 } 5534 5535 default: 5536 _, _ = key, value 5537 5538 } 5539 } 5540 *v = sv 5541 return nil 5542} 5543 5544func awsAwsjson11_deserializeDocumentShippingDetails(v **types.ShippingDetails, value interface{}) error { 5545 if v == nil { 5546 return fmt.Errorf("unexpected nil of type %T", v) 5547 } 5548 if value == nil { 5549 return nil 5550 } 5551 5552 shape, ok := value.(map[string]interface{}) 5553 if !ok { 5554 return fmt.Errorf("unexpected JSON type %v", value) 5555 } 5556 5557 var sv *types.ShippingDetails 5558 if *v == nil { 5559 sv = &types.ShippingDetails{} 5560 } else { 5561 sv = *v 5562 } 5563 5564 for key, value := range shape { 5565 switch key { 5566 case "InboundShipment": 5567 if err := awsAwsjson11_deserializeDocumentShipment(&sv.InboundShipment, value); err != nil { 5568 return err 5569 } 5570 5571 case "OutboundShipment": 5572 if err := awsAwsjson11_deserializeDocumentShipment(&sv.OutboundShipment, value); err != nil { 5573 return err 5574 } 5575 5576 case "ShippingOption": 5577 if value != nil { 5578 jtv, ok := value.(string) 5579 if !ok { 5580 return fmt.Errorf("expected ShippingOption to be of type string, got %T instead", value) 5581 } 5582 sv.ShippingOption = types.ShippingOption(jtv) 5583 } 5584 5585 default: 5586 _, _ = key, value 5587 5588 } 5589 } 5590 *v = sv 5591 return nil 5592} 5593 5594func awsAwsjson11_deserializeDocumentSnowconeDeviceConfiguration(v **types.SnowconeDeviceConfiguration, 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.SnowconeDeviceConfiguration 5608 if *v == nil { 5609 sv = &types.SnowconeDeviceConfiguration{} 5610 } else { 5611 sv = *v 5612 } 5613 5614 for key, value := range shape { 5615 switch key { 5616 case "WirelessConnection": 5617 if err := awsAwsjson11_deserializeDocumentWirelessConnection(&sv.WirelessConnection, value); err != nil { 5618 return err 5619 } 5620 5621 default: 5622 _, _ = key, value 5623 5624 } 5625 } 5626 *v = sv 5627 return nil 5628} 5629 5630func awsAwsjson11_deserializeDocumentTaxDocuments(v **types.TaxDocuments, value interface{}) error { 5631 if v == nil { 5632 return fmt.Errorf("unexpected nil of type %T", v) 5633 } 5634 if value == nil { 5635 return nil 5636 } 5637 5638 shape, ok := value.(map[string]interface{}) 5639 if !ok { 5640 return fmt.Errorf("unexpected JSON type %v", value) 5641 } 5642 5643 var sv *types.TaxDocuments 5644 if *v == nil { 5645 sv = &types.TaxDocuments{} 5646 } else { 5647 sv = *v 5648 } 5649 5650 for key, value := range shape { 5651 switch key { 5652 case "IND": 5653 if err := awsAwsjson11_deserializeDocumentINDTaxDocuments(&sv.IND, value); err != nil { 5654 return err 5655 } 5656 5657 default: 5658 _, _ = key, value 5659 5660 } 5661 } 5662 *v = sv 5663 return nil 5664} 5665 5666func awsAwsjson11_deserializeDocumentUnsupportedAddressException(v **types.UnsupportedAddressException, value interface{}) error { 5667 if v == nil { 5668 return fmt.Errorf("unexpected nil of type %T", v) 5669 } 5670 if value == nil { 5671 return nil 5672 } 5673 5674 shape, ok := value.(map[string]interface{}) 5675 if !ok { 5676 return fmt.Errorf("unexpected JSON type %v", value) 5677 } 5678 5679 var sv *types.UnsupportedAddressException 5680 if *v == nil { 5681 sv = &types.UnsupportedAddressException{} 5682 } else { 5683 sv = *v 5684 } 5685 5686 for key, value := range shape { 5687 switch key { 5688 case "Message": 5689 if value != nil { 5690 jtv, ok := value.(string) 5691 if !ok { 5692 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5693 } 5694 sv.Message = ptr.String(jtv) 5695 } 5696 5697 default: 5698 _, _ = key, value 5699 5700 } 5701 } 5702 *v = sv 5703 return nil 5704} 5705 5706func awsAwsjson11_deserializeDocumentWirelessConnection(v **types.WirelessConnection, value interface{}) error { 5707 if v == nil { 5708 return fmt.Errorf("unexpected nil of type %T", v) 5709 } 5710 if value == nil { 5711 return nil 5712 } 5713 5714 shape, ok := value.(map[string]interface{}) 5715 if !ok { 5716 return fmt.Errorf("unexpected JSON type %v", value) 5717 } 5718 5719 var sv *types.WirelessConnection 5720 if *v == nil { 5721 sv = &types.WirelessConnection{} 5722 } else { 5723 sv = *v 5724 } 5725 5726 for key, value := range shape { 5727 switch key { 5728 case "IsWifiEnabled": 5729 if value != nil { 5730 jtv, ok := value.(bool) 5731 if !ok { 5732 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5733 } 5734 sv.IsWifiEnabled = jtv 5735 } 5736 5737 default: 5738 _, _ = key, value 5739 5740 } 5741 } 5742 *v = sv 5743 return nil 5744} 5745 5746func awsAwsjson11_deserializeOpDocumentCancelClusterOutput(v **CancelClusterOutput, value interface{}) error { 5747 if v == nil { 5748 return fmt.Errorf("unexpected nil of type %T", v) 5749 } 5750 if value == nil { 5751 return nil 5752 } 5753 5754 shape, ok := value.(map[string]interface{}) 5755 if !ok { 5756 return fmt.Errorf("unexpected JSON type %v", value) 5757 } 5758 5759 var sv *CancelClusterOutput 5760 if *v == nil { 5761 sv = &CancelClusterOutput{} 5762 } else { 5763 sv = *v 5764 } 5765 5766 for key, value := range shape { 5767 switch key { 5768 default: 5769 _, _ = key, value 5770 5771 } 5772 } 5773 *v = sv 5774 return nil 5775} 5776 5777func awsAwsjson11_deserializeOpDocumentCancelJobOutput(v **CancelJobOutput, value interface{}) error { 5778 if v == nil { 5779 return fmt.Errorf("unexpected nil of type %T", v) 5780 } 5781 if value == nil { 5782 return nil 5783 } 5784 5785 shape, ok := value.(map[string]interface{}) 5786 if !ok { 5787 return fmt.Errorf("unexpected JSON type %v", value) 5788 } 5789 5790 var sv *CancelJobOutput 5791 if *v == nil { 5792 sv = &CancelJobOutput{} 5793 } else { 5794 sv = *v 5795 } 5796 5797 for key, value := range shape { 5798 switch key { 5799 default: 5800 _, _ = key, value 5801 5802 } 5803 } 5804 *v = sv 5805 return nil 5806} 5807 5808func awsAwsjson11_deserializeOpDocumentCreateAddressOutput(v **CreateAddressOutput, value interface{}) error { 5809 if v == nil { 5810 return fmt.Errorf("unexpected nil of type %T", v) 5811 } 5812 if value == nil { 5813 return nil 5814 } 5815 5816 shape, ok := value.(map[string]interface{}) 5817 if !ok { 5818 return fmt.Errorf("unexpected JSON type %v", value) 5819 } 5820 5821 var sv *CreateAddressOutput 5822 if *v == nil { 5823 sv = &CreateAddressOutput{} 5824 } else { 5825 sv = *v 5826 } 5827 5828 for key, value := range shape { 5829 switch key { 5830 case "AddressId": 5831 if value != nil { 5832 jtv, ok := value.(string) 5833 if !ok { 5834 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5835 } 5836 sv.AddressId = ptr.String(jtv) 5837 } 5838 5839 default: 5840 _, _ = key, value 5841 5842 } 5843 } 5844 *v = sv 5845 return nil 5846} 5847 5848func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, value interface{}) error { 5849 if v == nil { 5850 return fmt.Errorf("unexpected nil of type %T", v) 5851 } 5852 if value == nil { 5853 return nil 5854 } 5855 5856 shape, ok := value.(map[string]interface{}) 5857 if !ok { 5858 return fmt.Errorf("unexpected JSON type %v", value) 5859 } 5860 5861 var sv *CreateClusterOutput 5862 if *v == nil { 5863 sv = &CreateClusterOutput{} 5864 } else { 5865 sv = *v 5866 } 5867 5868 for key, value := range shape { 5869 switch key { 5870 case "ClusterId": 5871 if value != nil { 5872 jtv, ok := value.(string) 5873 if !ok { 5874 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 5875 } 5876 sv.ClusterId = ptr.String(jtv) 5877 } 5878 5879 default: 5880 _, _ = key, value 5881 5882 } 5883 } 5884 *v = sv 5885 return nil 5886} 5887 5888func awsAwsjson11_deserializeOpDocumentCreateJobOutput(v **CreateJobOutput, value interface{}) error { 5889 if v == nil { 5890 return fmt.Errorf("unexpected nil of type %T", v) 5891 } 5892 if value == nil { 5893 return nil 5894 } 5895 5896 shape, ok := value.(map[string]interface{}) 5897 if !ok { 5898 return fmt.Errorf("unexpected JSON type %v", value) 5899 } 5900 5901 var sv *CreateJobOutput 5902 if *v == nil { 5903 sv = &CreateJobOutput{} 5904 } else { 5905 sv = *v 5906 } 5907 5908 for key, value := range shape { 5909 switch key { 5910 case "JobId": 5911 if value != nil { 5912 jtv, ok := value.(string) 5913 if !ok { 5914 return fmt.Errorf("expected JobId to be of type string, got %T instead", value) 5915 } 5916 sv.JobId = ptr.String(jtv) 5917 } 5918 5919 default: 5920 _, _ = key, value 5921 5922 } 5923 } 5924 *v = sv 5925 return nil 5926} 5927 5928func awsAwsjson11_deserializeOpDocumentCreateLongTermPricingOutput(v **CreateLongTermPricingOutput, 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 *CreateLongTermPricingOutput 5942 if *v == nil { 5943 sv = &CreateLongTermPricingOutput{} 5944 } else { 5945 sv = *v 5946 } 5947 5948 for key, value := range shape { 5949 switch key { 5950 case "LongTermPricingId": 5951 if value != nil { 5952 jtv, ok := value.(string) 5953 if !ok { 5954 return fmt.Errorf("expected LongTermPricingId to be of type string, got %T instead", value) 5955 } 5956 sv.LongTermPricingId = ptr.String(jtv) 5957 } 5958 5959 default: 5960 _, _ = key, value 5961 5962 } 5963 } 5964 *v = sv 5965 return nil 5966} 5967 5968func awsAwsjson11_deserializeOpDocumentCreateReturnShippingLabelOutput(v **CreateReturnShippingLabelOutput, 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 *CreateReturnShippingLabelOutput 5982 if *v == nil { 5983 sv = &CreateReturnShippingLabelOutput{} 5984 } else { 5985 sv = *v 5986 } 5987 5988 for key, value := range shape { 5989 switch key { 5990 case "Status": 5991 if value != nil { 5992 jtv, ok := value.(string) 5993 if !ok { 5994 return fmt.Errorf("expected ShippingLabelStatus to be of type string, got %T instead", value) 5995 } 5996 sv.Status = types.ShippingLabelStatus(jtv) 5997 } 5998 5999 default: 6000 _, _ = key, value 6001 6002 } 6003 } 6004 *v = sv 6005 return nil 6006} 6007 6008func awsAwsjson11_deserializeOpDocumentDescribeAddressesOutput(v **DescribeAddressesOutput, 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 *DescribeAddressesOutput 6022 if *v == nil { 6023 sv = &DescribeAddressesOutput{} 6024 } else { 6025 sv = *v 6026 } 6027 6028 for key, value := range shape { 6029 switch key { 6030 case "Addresses": 6031 if err := awsAwsjson11_deserializeDocumentAddressList(&sv.Addresses, value); err != nil { 6032 return err 6033 } 6034 6035 case "NextToken": 6036 if value != nil { 6037 jtv, ok := value.(string) 6038 if !ok { 6039 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6040 } 6041 sv.NextToken = ptr.String(jtv) 6042 } 6043 6044 default: 6045 _, _ = key, value 6046 6047 } 6048 } 6049 *v = sv 6050 return nil 6051} 6052 6053func awsAwsjson11_deserializeOpDocumentDescribeAddressOutput(v **DescribeAddressOutput, value interface{}) error { 6054 if v == nil { 6055 return fmt.Errorf("unexpected nil of type %T", v) 6056 } 6057 if value == nil { 6058 return nil 6059 } 6060 6061 shape, ok := value.(map[string]interface{}) 6062 if !ok { 6063 return fmt.Errorf("unexpected JSON type %v", value) 6064 } 6065 6066 var sv *DescribeAddressOutput 6067 if *v == nil { 6068 sv = &DescribeAddressOutput{} 6069 } else { 6070 sv = *v 6071 } 6072 6073 for key, value := range shape { 6074 switch key { 6075 case "Address": 6076 if err := awsAwsjson11_deserializeDocumentAddress(&sv.Address, value); err != nil { 6077 return err 6078 } 6079 6080 default: 6081 _, _ = key, value 6082 6083 } 6084 } 6085 *v = sv 6086 return nil 6087} 6088 6089func awsAwsjson11_deserializeOpDocumentDescribeClusterOutput(v **DescribeClusterOutput, value interface{}) error { 6090 if v == nil { 6091 return fmt.Errorf("unexpected nil of type %T", v) 6092 } 6093 if value == nil { 6094 return nil 6095 } 6096 6097 shape, ok := value.(map[string]interface{}) 6098 if !ok { 6099 return fmt.Errorf("unexpected JSON type %v", value) 6100 } 6101 6102 var sv *DescribeClusterOutput 6103 if *v == nil { 6104 sv = &DescribeClusterOutput{} 6105 } else { 6106 sv = *v 6107 } 6108 6109 for key, value := range shape { 6110 switch key { 6111 case "ClusterMetadata": 6112 if err := awsAwsjson11_deserializeDocumentClusterMetadata(&sv.ClusterMetadata, value); err != nil { 6113 return err 6114 } 6115 6116 default: 6117 _, _ = key, value 6118 6119 } 6120 } 6121 *v = sv 6122 return nil 6123} 6124 6125func awsAwsjson11_deserializeOpDocumentDescribeJobOutput(v **DescribeJobOutput, value interface{}) error { 6126 if v == nil { 6127 return fmt.Errorf("unexpected nil of type %T", v) 6128 } 6129 if value == nil { 6130 return nil 6131 } 6132 6133 shape, ok := value.(map[string]interface{}) 6134 if !ok { 6135 return fmt.Errorf("unexpected JSON type %v", value) 6136 } 6137 6138 var sv *DescribeJobOutput 6139 if *v == nil { 6140 sv = &DescribeJobOutput{} 6141 } else { 6142 sv = *v 6143 } 6144 6145 for key, value := range shape { 6146 switch key { 6147 case "JobMetadata": 6148 if err := awsAwsjson11_deserializeDocumentJobMetadata(&sv.JobMetadata, value); err != nil { 6149 return err 6150 } 6151 6152 case "SubJobMetadata": 6153 if err := awsAwsjson11_deserializeDocumentJobMetadataList(&sv.SubJobMetadata, value); err != nil { 6154 return err 6155 } 6156 6157 default: 6158 _, _ = key, value 6159 6160 } 6161 } 6162 *v = sv 6163 return nil 6164} 6165 6166func awsAwsjson11_deserializeOpDocumentDescribeReturnShippingLabelOutput(v **DescribeReturnShippingLabelOutput, value interface{}) error { 6167 if v == nil { 6168 return fmt.Errorf("unexpected nil of type %T", v) 6169 } 6170 if value == nil { 6171 return nil 6172 } 6173 6174 shape, ok := value.(map[string]interface{}) 6175 if !ok { 6176 return fmt.Errorf("unexpected JSON type %v", value) 6177 } 6178 6179 var sv *DescribeReturnShippingLabelOutput 6180 if *v == nil { 6181 sv = &DescribeReturnShippingLabelOutput{} 6182 } else { 6183 sv = *v 6184 } 6185 6186 for key, value := range shape { 6187 switch key { 6188 case "ExpirationDate": 6189 if value != nil { 6190 jtv, ok := value.(json.Number) 6191 if !ok { 6192 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6193 } 6194 f64, err := jtv.Float64() 6195 if err != nil { 6196 return err 6197 } 6198 sv.ExpirationDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6199 } 6200 6201 case "Status": 6202 if value != nil { 6203 jtv, ok := value.(string) 6204 if !ok { 6205 return fmt.Errorf("expected ShippingLabelStatus to be of type string, got %T instead", value) 6206 } 6207 sv.Status = types.ShippingLabelStatus(jtv) 6208 } 6209 6210 default: 6211 _, _ = key, value 6212 6213 } 6214 } 6215 *v = sv 6216 return nil 6217} 6218 6219func awsAwsjson11_deserializeOpDocumentGetJobManifestOutput(v **GetJobManifestOutput, value interface{}) error { 6220 if v == nil { 6221 return fmt.Errorf("unexpected nil of type %T", v) 6222 } 6223 if value == nil { 6224 return nil 6225 } 6226 6227 shape, ok := value.(map[string]interface{}) 6228 if !ok { 6229 return fmt.Errorf("unexpected JSON type %v", value) 6230 } 6231 6232 var sv *GetJobManifestOutput 6233 if *v == nil { 6234 sv = &GetJobManifestOutput{} 6235 } else { 6236 sv = *v 6237 } 6238 6239 for key, value := range shape { 6240 switch key { 6241 case "ManifestURI": 6242 if value != nil { 6243 jtv, ok := value.(string) 6244 if !ok { 6245 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6246 } 6247 sv.ManifestURI = ptr.String(jtv) 6248 } 6249 6250 default: 6251 _, _ = key, value 6252 6253 } 6254 } 6255 *v = sv 6256 return nil 6257} 6258 6259func awsAwsjson11_deserializeOpDocumentGetJobUnlockCodeOutput(v **GetJobUnlockCodeOutput, value interface{}) error { 6260 if v == nil { 6261 return fmt.Errorf("unexpected nil of type %T", v) 6262 } 6263 if value == nil { 6264 return nil 6265 } 6266 6267 shape, ok := value.(map[string]interface{}) 6268 if !ok { 6269 return fmt.Errorf("unexpected JSON type %v", value) 6270 } 6271 6272 var sv *GetJobUnlockCodeOutput 6273 if *v == nil { 6274 sv = &GetJobUnlockCodeOutput{} 6275 } else { 6276 sv = *v 6277 } 6278 6279 for key, value := range shape { 6280 switch key { 6281 case "UnlockCode": 6282 if value != nil { 6283 jtv, ok := value.(string) 6284 if !ok { 6285 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6286 } 6287 sv.UnlockCode = ptr.String(jtv) 6288 } 6289 6290 default: 6291 _, _ = key, value 6292 6293 } 6294 } 6295 *v = sv 6296 return nil 6297} 6298 6299func awsAwsjson11_deserializeOpDocumentGetSnowballUsageOutput(v **GetSnowballUsageOutput, value interface{}) error { 6300 if v == nil { 6301 return fmt.Errorf("unexpected nil of type %T", v) 6302 } 6303 if value == nil { 6304 return nil 6305 } 6306 6307 shape, ok := value.(map[string]interface{}) 6308 if !ok { 6309 return fmt.Errorf("unexpected JSON type %v", value) 6310 } 6311 6312 var sv *GetSnowballUsageOutput 6313 if *v == nil { 6314 sv = &GetSnowballUsageOutput{} 6315 } else { 6316 sv = *v 6317 } 6318 6319 for key, value := range shape { 6320 switch key { 6321 case "SnowballLimit": 6322 if value != nil { 6323 jtv, ok := value.(json.Number) 6324 if !ok { 6325 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6326 } 6327 i64, err := jtv.Int64() 6328 if err != nil { 6329 return err 6330 } 6331 sv.SnowballLimit = ptr.Int32(int32(i64)) 6332 } 6333 6334 case "SnowballsInUse": 6335 if value != nil { 6336 jtv, ok := value.(json.Number) 6337 if !ok { 6338 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6339 } 6340 i64, err := jtv.Int64() 6341 if err != nil { 6342 return err 6343 } 6344 sv.SnowballsInUse = ptr.Int32(int32(i64)) 6345 } 6346 6347 default: 6348 _, _ = key, value 6349 6350 } 6351 } 6352 *v = sv 6353 return nil 6354} 6355 6356func awsAwsjson11_deserializeOpDocumentGetSoftwareUpdatesOutput(v **GetSoftwareUpdatesOutput, value interface{}) error { 6357 if v == nil { 6358 return fmt.Errorf("unexpected nil of type %T", v) 6359 } 6360 if value == nil { 6361 return nil 6362 } 6363 6364 shape, ok := value.(map[string]interface{}) 6365 if !ok { 6366 return fmt.Errorf("unexpected JSON type %v", value) 6367 } 6368 6369 var sv *GetSoftwareUpdatesOutput 6370 if *v == nil { 6371 sv = &GetSoftwareUpdatesOutput{} 6372 } else { 6373 sv = *v 6374 } 6375 6376 for key, value := range shape { 6377 switch key { 6378 case "UpdatesURI": 6379 if value != nil { 6380 jtv, ok := value.(string) 6381 if !ok { 6382 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6383 } 6384 sv.UpdatesURI = ptr.String(jtv) 6385 } 6386 6387 default: 6388 _, _ = key, value 6389 6390 } 6391 } 6392 *v = sv 6393 return nil 6394} 6395 6396func awsAwsjson11_deserializeOpDocumentListClusterJobsOutput(v **ListClusterJobsOutput, value interface{}) error { 6397 if v == nil { 6398 return fmt.Errorf("unexpected nil of type %T", v) 6399 } 6400 if value == nil { 6401 return nil 6402 } 6403 6404 shape, ok := value.(map[string]interface{}) 6405 if !ok { 6406 return fmt.Errorf("unexpected JSON type %v", value) 6407 } 6408 6409 var sv *ListClusterJobsOutput 6410 if *v == nil { 6411 sv = &ListClusterJobsOutput{} 6412 } else { 6413 sv = *v 6414 } 6415 6416 for key, value := range shape { 6417 switch key { 6418 case "JobListEntries": 6419 if err := awsAwsjson11_deserializeDocumentJobListEntryList(&sv.JobListEntries, value); err != nil { 6420 return err 6421 } 6422 6423 case "NextToken": 6424 if value != nil { 6425 jtv, ok := value.(string) 6426 if !ok { 6427 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6428 } 6429 sv.NextToken = ptr.String(jtv) 6430 } 6431 6432 default: 6433 _, _ = key, value 6434 6435 } 6436 } 6437 *v = sv 6438 return nil 6439} 6440 6441func awsAwsjson11_deserializeOpDocumentListClustersOutput(v **ListClustersOutput, value interface{}) error { 6442 if v == nil { 6443 return fmt.Errorf("unexpected nil of type %T", v) 6444 } 6445 if value == nil { 6446 return nil 6447 } 6448 6449 shape, ok := value.(map[string]interface{}) 6450 if !ok { 6451 return fmt.Errorf("unexpected JSON type %v", value) 6452 } 6453 6454 var sv *ListClustersOutput 6455 if *v == nil { 6456 sv = &ListClustersOutput{} 6457 } else { 6458 sv = *v 6459 } 6460 6461 for key, value := range shape { 6462 switch key { 6463 case "ClusterListEntries": 6464 if err := awsAwsjson11_deserializeDocumentClusterListEntryList(&sv.ClusterListEntries, value); err != nil { 6465 return err 6466 } 6467 6468 case "NextToken": 6469 if value != nil { 6470 jtv, ok := value.(string) 6471 if !ok { 6472 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6473 } 6474 sv.NextToken = ptr.String(jtv) 6475 } 6476 6477 default: 6478 _, _ = key, value 6479 6480 } 6481 } 6482 *v = sv 6483 return nil 6484} 6485 6486func awsAwsjson11_deserializeOpDocumentListCompatibleImagesOutput(v **ListCompatibleImagesOutput, value interface{}) error { 6487 if v == nil { 6488 return fmt.Errorf("unexpected nil of type %T", v) 6489 } 6490 if value == nil { 6491 return nil 6492 } 6493 6494 shape, ok := value.(map[string]interface{}) 6495 if !ok { 6496 return fmt.Errorf("unexpected JSON type %v", value) 6497 } 6498 6499 var sv *ListCompatibleImagesOutput 6500 if *v == nil { 6501 sv = &ListCompatibleImagesOutput{} 6502 } else { 6503 sv = *v 6504 } 6505 6506 for key, value := range shape { 6507 switch key { 6508 case "CompatibleImages": 6509 if err := awsAwsjson11_deserializeDocumentCompatibleImageList(&sv.CompatibleImages, value); err != nil { 6510 return err 6511 } 6512 6513 case "NextToken": 6514 if value != nil { 6515 jtv, ok := value.(string) 6516 if !ok { 6517 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6518 } 6519 sv.NextToken = ptr.String(jtv) 6520 } 6521 6522 default: 6523 _, _ = key, value 6524 6525 } 6526 } 6527 *v = sv 6528 return nil 6529} 6530 6531func awsAwsjson11_deserializeOpDocumentListJobsOutput(v **ListJobsOutput, value interface{}) error { 6532 if v == nil { 6533 return fmt.Errorf("unexpected nil of type %T", v) 6534 } 6535 if value == nil { 6536 return nil 6537 } 6538 6539 shape, ok := value.(map[string]interface{}) 6540 if !ok { 6541 return fmt.Errorf("unexpected JSON type %v", value) 6542 } 6543 6544 var sv *ListJobsOutput 6545 if *v == nil { 6546 sv = &ListJobsOutput{} 6547 } else { 6548 sv = *v 6549 } 6550 6551 for key, value := range shape { 6552 switch key { 6553 case "JobListEntries": 6554 if err := awsAwsjson11_deserializeDocumentJobListEntryList(&sv.JobListEntries, value); err != nil { 6555 return err 6556 } 6557 6558 case "NextToken": 6559 if value != nil { 6560 jtv, ok := value.(string) 6561 if !ok { 6562 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6563 } 6564 sv.NextToken = ptr.String(jtv) 6565 } 6566 6567 default: 6568 _, _ = key, value 6569 6570 } 6571 } 6572 *v = sv 6573 return nil 6574} 6575 6576func awsAwsjson11_deserializeOpDocumentListLongTermPricingOutput(v **ListLongTermPricingOutput, value interface{}) error { 6577 if v == nil { 6578 return fmt.Errorf("unexpected nil of type %T", v) 6579 } 6580 if value == nil { 6581 return nil 6582 } 6583 6584 shape, ok := value.(map[string]interface{}) 6585 if !ok { 6586 return fmt.Errorf("unexpected JSON type %v", value) 6587 } 6588 6589 var sv *ListLongTermPricingOutput 6590 if *v == nil { 6591 sv = &ListLongTermPricingOutput{} 6592 } else { 6593 sv = *v 6594 } 6595 6596 for key, value := range shape { 6597 switch key { 6598 case "LongTermPricingEntries": 6599 if err := awsAwsjson11_deserializeDocumentLongTermPricingEntryList(&sv.LongTermPricingEntries, value); err != nil { 6600 return err 6601 } 6602 6603 case "NextToken": 6604 if value != nil { 6605 jtv, ok := value.(string) 6606 if !ok { 6607 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6608 } 6609 sv.NextToken = ptr.String(jtv) 6610 } 6611 6612 default: 6613 _, _ = key, value 6614 6615 } 6616 } 6617 *v = sv 6618 return nil 6619} 6620 6621func awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(v **UpdateClusterOutput, value interface{}) error { 6622 if v == nil { 6623 return fmt.Errorf("unexpected nil of type %T", v) 6624 } 6625 if value == nil { 6626 return nil 6627 } 6628 6629 shape, ok := value.(map[string]interface{}) 6630 if !ok { 6631 return fmt.Errorf("unexpected JSON type %v", value) 6632 } 6633 6634 var sv *UpdateClusterOutput 6635 if *v == nil { 6636 sv = &UpdateClusterOutput{} 6637 } else { 6638 sv = *v 6639 } 6640 6641 for key, value := range shape { 6642 switch key { 6643 default: 6644 _, _ = key, value 6645 6646 } 6647 } 6648 *v = sv 6649 return nil 6650} 6651 6652func awsAwsjson11_deserializeOpDocumentUpdateJobOutput(v **UpdateJobOutput, value interface{}) error { 6653 if v == nil { 6654 return fmt.Errorf("unexpected nil of type %T", v) 6655 } 6656 if value == nil { 6657 return nil 6658 } 6659 6660 shape, ok := value.(map[string]interface{}) 6661 if !ok { 6662 return fmt.Errorf("unexpected JSON type %v", value) 6663 } 6664 6665 var sv *UpdateJobOutput 6666 if *v == nil { 6667 sv = &UpdateJobOutput{} 6668 } else { 6669 sv = *v 6670 } 6671 6672 for key, value := range shape { 6673 switch key { 6674 default: 6675 _, _ = key, value 6676 6677 } 6678 } 6679 *v = sv 6680 return nil 6681} 6682 6683func awsAwsjson11_deserializeOpDocumentUpdateJobShipmentStateOutput(v **UpdateJobShipmentStateOutput, value interface{}) error { 6684 if v == nil { 6685 return fmt.Errorf("unexpected nil of type %T", v) 6686 } 6687 if value == nil { 6688 return nil 6689 } 6690 6691 shape, ok := value.(map[string]interface{}) 6692 if !ok { 6693 return fmt.Errorf("unexpected JSON type %v", value) 6694 } 6695 6696 var sv *UpdateJobShipmentStateOutput 6697 if *v == nil { 6698 sv = &UpdateJobShipmentStateOutput{} 6699 } else { 6700 sv = *v 6701 } 6702 6703 for key, value := range shape { 6704 switch key { 6705 default: 6706 _, _ = key, value 6707 6708 } 6709 } 6710 *v = sv 6711 return nil 6712} 6713 6714func awsAwsjson11_deserializeOpDocumentUpdateLongTermPricingOutput(v **UpdateLongTermPricingOutput, value interface{}) error { 6715 if v == nil { 6716 return fmt.Errorf("unexpected nil of type %T", v) 6717 } 6718 if value == nil { 6719 return nil 6720 } 6721 6722 shape, ok := value.(map[string]interface{}) 6723 if !ok { 6724 return fmt.Errorf("unexpected JSON type %v", value) 6725 } 6726 6727 var sv *UpdateLongTermPricingOutput 6728 if *v == nil { 6729 sv = &UpdateLongTermPricingOutput{} 6730 } else { 6731 sv = *v 6732 } 6733 6734 for key, value := range shape { 6735 switch key { 6736 default: 6737 _, _ = key, value 6738 6739 } 6740 } 6741 *v = sv 6742 return nil 6743} 6744