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