1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ecs 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/ecs/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpCreateCapacityProvider struct { 23} 24 25func (*awsAwsjson11_deserializeOpCreateCapacityProvider) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCreateCapacityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCapacityProvider(response, &metadata) 44 } 45 output := &CreateCapacityProviderOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentCreateCapacityProviderOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorCreateCapacityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("ClientException", errorCode): 121 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 122 123 case strings.EqualFold("InvalidParameterException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 125 126 case strings.EqualFold("LimitExceededException", errorCode): 127 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 128 129 case strings.EqualFold("ServerException", errorCode): 130 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 131 132 case strings.EqualFold("UpdateInProgressException", errorCode): 133 return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody) 134 135 default: 136 genericError := &smithy.GenericAPIError{ 137 Code: errorCode, 138 Message: errorMessage, 139 } 140 return genericError 141 142 } 143} 144 145type awsAwsjson11_deserializeOpCreateCluster struct { 146} 147 148func (*awsAwsjson11_deserializeOpCreateCluster) ID() string { 149 return "OperationDeserializer" 150} 151 152func (m *awsAwsjson11_deserializeOpCreateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 153 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 154) { 155 out, metadata, err = next.HandleDeserialize(ctx, in) 156 if err != nil { 157 return out, metadata, err 158 } 159 160 response, ok := out.RawResponse.(*smithyhttp.Response) 161 if !ok { 162 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 163 } 164 165 if response.StatusCode < 200 || response.StatusCode >= 300 { 166 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata) 167 } 168 output := &CreateClusterOutput{} 169 out.Result = output 170 171 var buff [1024]byte 172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 173 174 body := io.TeeReader(response.Body, ringBuffer) 175 decoder := json.NewDecoder(body) 176 decoder.UseNumber() 177 var shape interface{} 178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 179 var snapshot bytes.Buffer 180 io.Copy(&snapshot, ringBuffer) 181 err = &smithy.DeserializationError{ 182 Err: fmt.Errorf("failed to decode response body, %w", err), 183 Snapshot: snapshot.Bytes(), 184 } 185 return out, metadata, err 186 } 187 188 err = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&output, shape) 189 if err != nil { 190 var snapshot bytes.Buffer 191 io.Copy(&snapshot, ringBuffer) 192 err = &smithy.DeserializationError{ 193 Err: fmt.Errorf("failed to decode response body, %w", err), 194 Snapshot: snapshot.Bytes(), 195 } 196 return out, metadata, err 197 } 198 199 return out, metadata, err 200} 201 202func awsAwsjson11_deserializeOpErrorCreateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 203 var errorBuffer bytes.Buffer 204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 206 } 207 errorBody := bytes.NewReader(errorBuffer.Bytes()) 208 209 errorCode := "UnknownError" 210 errorMessage := errorCode 211 212 code := response.Header.Get("X-Amzn-ErrorType") 213 if len(code) != 0 { 214 errorCode = restjson.SanitizeErrorCode(code) 215 } 216 217 var buff [1024]byte 218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 219 220 body := io.TeeReader(errorBody, ringBuffer) 221 decoder := json.NewDecoder(body) 222 decoder.UseNumber() 223 code, message, err := restjson.GetErrorInfo(decoder) 224 if err != nil { 225 var snapshot bytes.Buffer 226 io.Copy(&snapshot, ringBuffer) 227 err = &smithy.DeserializationError{ 228 Err: fmt.Errorf("failed to decode response body, %w", err), 229 Snapshot: snapshot.Bytes(), 230 } 231 return err 232 } 233 234 errorBody.Seek(0, io.SeekStart) 235 if len(code) != 0 { 236 errorCode = restjson.SanitizeErrorCode(code) 237 } 238 if len(message) != 0 { 239 errorMessage = message 240 } 241 242 switch { 243 case strings.EqualFold("ClientException", errorCode): 244 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 245 246 case strings.EqualFold("InvalidParameterException", errorCode): 247 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 248 249 case strings.EqualFold("ServerException", errorCode): 250 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 251 252 default: 253 genericError := &smithy.GenericAPIError{ 254 Code: errorCode, 255 Message: errorMessage, 256 } 257 return genericError 258 259 } 260} 261 262type awsAwsjson11_deserializeOpCreateService struct { 263} 264 265func (*awsAwsjson11_deserializeOpCreateService) ID() string { 266 return "OperationDeserializer" 267} 268 269func (m *awsAwsjson11_deserializeOpCreateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 270 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 271) { 272 out, metadata, err = next.HandleDeserialize(ctx, in) 273 if err != nil { 274 return out, metadata, err 275 } 276 277 response, ok := out.RawResponse.(*smithyhttp.Response) 278 if !ok { 279 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 280 } 281 282 if response.StatusCode < 200 || response.StatusCode >= 300 { 283 return out, metadata, awsAwsjson11_deserializeOpErrorCreateService(response, &metadata) 284 } 285 output := &CreateServiceOutput{} 286 out.Result = output 287 288 var buff [1024]byte 289 ringBuffer := smithyio.NewRingBuffer(buff[:]) 290 291 body := io.TeeReader(response.Body, ringBuffer) 292 decoder := json.NewDecoder(body) 293 decoder.UseNumber() 294 var shape interface{} 295 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 296 var snapshot bytes.Buffer 297 io.Copy(&snapshot, ringBuffer) 298 err = &smithy.DeserializationError{ 299 Err: fmt.Errorf("failed to decode response body, %w", err), 300 Snapshot: snapshot.Bytes(), 301 } 302 return out, metadata, err 303 } 304 305 err = awsAwsjson11_deserializeOpDocumentCreateServiceOutput(&output, shape) 306 if err != nil { 307 var snapshot bytes.Buffer 308 io.Copy(&snapshot, ringBuffer) 309 err = &smithy.DeserializationError{ 310 Err: fmt.Errorf("failed to decode response body, %w", err), 311 Snapshot: snapshot.Bytes(), 312 } 313 return out, metadata, err 314 } 315 316 return out, metadata, err 317} 318 319func awsAwsjson11_deserializeOpErrorCreateService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 320 var errorBuffer bytes.Buffer 321 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 322 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 323 } 324 errorBody := bytes.NewReader(errorBuffer.Bytes()) 325 326 errorCode := "UnknownError" 327 errorMessage := errorCode 328 329 code := response.Header.Get("X-Amzn-ErrorType") 330 if len(code) != 0 { 331 errorCode = restjson.SanitizeErrorCode(code) 332 } 333 334 var buff [1024]byte 335 ringBuffer := smithyio.NewRingBuffer(buff[:]) 336 337 body := io.TeeReader(errorBody, ringBuffer) 338 decoder := json.NewDecoder(body) 339 decoder.UseNumber() 340 code, message, err := restjson.GetErrorInfo(decoder) 341 if err != nil { 342 var snapshot bytes.Buffer 343 io.Copy(&snapshot, ringBuffer) 344 err = &smithy.DeserializationError{ 345 Err: fmt.Errorf("failed to decode response body, %w", err), 346 Snapshot: snapshot.Bytes(), 347 } 348 return err 349 } 350 351 errorBody.Seek(0, io.SeekStart) 352 if len(code) != 0 { 353 errorCode = restjson.SanitizeErrorCode(code) 354 } 355 if len(message) != 0 { 356 errorMessage = message 357 } 358 359 switch { 360 case strings.EqualFold("AccessDeniedException", errorCode): 361 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 362 363 case strings.EqualFold("ClientException", errorCode): 364 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 365 366 case strings.EqualFold("ClusterNotFoundException", errorCode): 367 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 368 369 case strings.EqualFold("InvalidParameterException", errorCode): 370 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 371 372 case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode): 373 return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody) 374 375 case strings.EqualFold("PlatformUnknownException", errorCode): 376 return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody) 377 378 case strings.EqualFold("ServerException", errorCode): 379 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 380 381 case strings.EqualFold("UnsupportedFeatureException", errorCode): 382 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 383 384 default: 385 genericError := &smithy.GenericAPIError{ 386 Code: errorCode, 387 Message: errorMessage, 388 } 389 return genericError 390 391 } 392} 393 394type awsAwsjson11_deserializeOpCreateTaskSet struct { 395} 396 397func (*awsAwsjson11_deserializeOpCreateTaskSet) ID() string { 398 return "OperationDeserializer" 399} 400 401func (m *awsAwsjson11_deserializeOpCreateTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 402 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 403) { 404 out, metadata, err = next.HandleDeserialize(ctx, in) 405 if err != nil { 406 return out, metadata, err 407 } 408 409 response, ok := out.RawResponse.(*smithyhttp.Response) 410 if !ok { 411 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 412 } 413 414 if response.StatusCode < 200 || response.StatusCode >= 300 { 415 return out, metadata, awsAwsjson11_deserializeOpErrorCreateTaskSet(response, &metadata) 416 } 417 output := &CreateTaskSetOutput{} 418 out.Result = output 419 420 var buff [1024]byte 421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 422 423 body := io.TeeReader(response.Body, ringBuffer) 424 decoder := json.NewDecoder(body) 425 decoder.UseNumber() 426 var shape interface{} 427 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 428 var snapshot bytes.Buffer 429 io.Copy(&snapshot, ringBuffer) 430 err = &smithy.DeserializationError{ 431 Err: fmt.Errorf("failed to decode response body, %w", err), 432 Snapshot: snapshot.Bytes(), 433 } 434 return out, metadata, err 435 } 436 437 err = awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(&output, shape) 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 out, metadata, err 446 } 447 448 return out, metadata, err 449} 450 451func awsAwsjson11_deserializeOpErrorCreateTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 452 var errorBuffer bytes.Buffer 453 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 454 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 455 } 456 errorBody := bytes.NewReader(errorBuffer.Bytes()) 457 458 errorCode := "UnknownError" 459 errorMessage := errorCode 460 461 code := response.Header.Get("X-Amzn-ErrorType") 462 if len(code) != 0 { 463 errorCode = restjson.SanitizeErrorCode(code) 464 } 465 466 var buff [1024]byte 467 ringBuffer := smithyio.NewRingBuffer(buff[:]) 468 469 body := io.TeeReader(errorBody, ringBuffer) 470 decoder := json.NewDecoder(body) 471 decoder.UseNumber() 472 code, message, err := restjson.GetErrorInfo(decoder) 473 if err != nil { 474 var snapshot bytes.Buffer 475 io.Copy(&snapshot, ringBuffer) 476 err = &smithy.DeserializationError{ 477 Err: fmt.Errorf("failed to decode response body, %w", err), 478 Snapshot: snapshot.Bytes(), 479 } 480 return err 481 } 482 483 errorBody.Seek(0, io.SeekStart) 484 if len(code) != 0 { 485 errorCode = restjson.SanitizeErrorCode(code) 486 } 487 if len(message) != 0 { 488 errorMessage = message 489 } 490 491 switch { 492 case strings.EqualFold("AccessDeniedException", errorCode): 493 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 494 495 case strings.EqualFold("ClientException", errorCode): 496 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 497 498 case strings.EqualFold("ClusterNotFoundException", errorCode): 499 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 500 501 case strings.EqualFold("InvalidParameterException", errorCode): 502 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 503 504 case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode): 505 return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody) 506 507 case strings.EqualFold("PlatformUnknownException", errorCode): 508 return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody) 509 510 case strings.EqualFold("ServerException", errorCode): 511 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 512 513 case strings.EqualFold("ServiceNotActiveException", errorCode): 514 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 515 516 case strings.EqualFold("ServiceNotFoundException", errorCode): 517 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 518 519 case strings.EqualFold("UnsupportedFeatureException", errorCode): 520 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 521 522 default: 523 genericError := &smithy.GenericAPIError{ 524 Code: errorCode, 525 Message: errorMessage, 526 } 527 return genericError 528 529 } 530} 531 532type awsAwsjson11_deserializeOpDeleteAccountSetting struct { 533} 534 535func (*awsAwsjson11_deserializeOpDeleteAccountSetting) ID() string { 536 return "OperationDeserializer" 537} 538 539func (m *awsAwsjson11_deserializeOpDeleteAccountSetting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 540 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 541) { 542 out, metadata, err = next.HandleDeserialize(ctx, in) 543 if err != nil { 544 return out, metadata, err 545 } 546 547 response, ok := out.RawResponse.(*smithyhttp.Response) 548 if !ok { 549 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 550 } 551 552 if response.StatusCode < 200 || response.StatusCode >= 300 { 553 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAccountSetting(response, &metadata) 554 } 555 output := &DeleteAccountSettingOutput{} 556 out.Result = output 557 558 var buff [1024]byte 559 ringBuffer := smithyio.NewRingBuffer(buff[:]) 560 561 body := io.TeeReader(response.Body, ringBuffer) 562 decoder := json.NewDecoder(body) 563 decoder.UseNumber() 564 var shape interface{} 565 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 566 var snapshot bytes.Buffer 567 io.Copy(&snapshot, ringBuffer) 568 err = &smithy.DeserializationError{ 569 Err: fmt.Errorf("failed to decode response body, %w", err), 570 Snapshot: snapshot.Bytes(), 571 } 572 return out, metadata, err 573 } 574 575 err = awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(&output, shape) 576 if err != nil { 577 var snapshot bytes.Buffer 578 io.Copy(&snapshot, ringBuffer) 579 err = &smithy.DeserializationError{ 580 Err: fmt.Errorf("failed to decode response body, %w", err), 581 Snapshot: snapshot.Bytes(), 582 } 583 return out, metadata, err 584 } 585 586 return out, metadata, err 587} 588 589func awsAwsjson11_deserializeOpErrorDeleteAccountSetting(response *smithyhttp.Response, metadata *middleware.Metadata) error { 590 var errorBuffer bytes.Buffer 591 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 592 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 593 } 594 errorBody := bytes.NewReader(errorBuffer.Bytes()) 595 596 errorCode := "UnknownError" 597 errorMessage := errorCode 598 599 code := response.Header.Get("X-Amzn-ErrorType") 600 if len(code) != 0 { 601 errorCode = restjson.SanitizeErrorCode(code) 602 } 603 604 var buff [1024]byte 605 ringBuffer := smithyio.NewRingBuffer(buff[:]) 606 607 body := io.TeeReader(errorBody, ringBuffer) 608 decoder := json.NewDecoder(body) 609 decoder.UseNumber() 610 code, message, err := restjson.GetErrorInfo(decoder) 611 if err != nil { 612 var snapshot bytes.Buffer 613 io.Copy(&snapshot, ringBuffer) 614 err = &smithy.DeserializationError{ 615 Err: fmt.Errorf("failed to decode response body, %w", err), 616 Snapshot: snapshot.Bytes(), 617 } 618 return err 619 } 620 621 errorBody.Seek(0, io.SeekStart) 622 if len(code) != 0 { 623 errorCode = restjson.SanitizeErrorCode(code) 624 } 625 if len(message) != 0 { 626 errorMessage = message 627 } 628 629 switch { 630 case strings.EqualFold("ClientException", errorCode): 631 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 632 633 case strings.EqualFold("InvalidParameterException", errorCode): 634 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 635 636 case strings.EqualFold("ServerException", errorCode): 637 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 638 639 default: 640 genericError := &smithy.GenericAPIError{ 641 Code: errorCode, 642 Message: errorMessage, 643 } 644 return genericError 645 646 } 647} 648 649type awsAwsjson11_deserializeOpDeleteAttributes struct { 650} 651 652func (*awsAwsjson11_deserializeOpDeleteAttributes) ID() string { 653 return "OperationDeserializer" 654} 655 656func (m *awsAwsjson11_deserializeOpDeleteAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 657 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 658) { 659 out, metadata, err = next.HandleDeserialize(ctx, in) 660 if err != nil { 661 return out, metadata, err 662 } 663 664 response, ok := out.RawResponse.(*smithyhttp.Response) 665 if !ok { 666 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 667 } 668 669 if response.StatusCode < 200 || response.StatusCode >= 300 { 670 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAttributes(response, &metadata) 671 } 672 output := &DeleteAttributesOutput{} 673 out.Result = output 674 675 var buff [1024]byte 676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 677 678 body := io.TeeReader(response.Body, ringBuffer) 679 decoder := json.NewDecoder(body) 680 decoder.UseNumber() 681 var shape interface{} 682 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 683 var snapshot bytes.Buffer 684 io.Copy(&snapshot, ringBuffer) 685 err = &smithy.DeserializationError{ 686 Err: fmt.Errorf("failed to decode response body, %w", err), 687 Snapshot: snapshot.Bytes(), 688 } 689 return out, metadata, err 690 } 691 692 err = awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(&output, shape) 693 if err != nil { 694 var snapshot bytes.Buffer 695 io.Copy(&snapshot, ringBuffer) 696 err = &smithy.DeserializationError{ 697 Err: fmt.Errorf("failed to decode response body, %w", err), 698 Snapshot: snapshot.Bytes(), 699 } 700 return out, metadata, err 701 } 702 703 return out, metadata, err 704} 705 706func awsAwsjson11_deserializeOpErrorDeleteAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 707 var errorBuffer bytes.Buffer 708 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 709 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 710 } 711 errorBody := bytes.NewReader(errorBuffer.Bytes()) 712 713 errorCode := "UnknownError" 714 errorMessage := errorCode 715 716 code := response.Header.Get("X-Amzn-ErrorType") 717 if len(code) != 0 { 718 errorCode = restjson.SanitizeErrorCode(code) 719 } 720 721 var buff [1024]byte 722 ringBuffer := smithyio.NewRingBuffer(buff[:]) 723 724 body := io.TeeReader(errorBody, ringBuffer) 725 decoder := json.NewDecoder(body) 726 decoder.UseNumber() 727 code, message, err := restjson.GetErrorInfo(decoder) 728 if err != nil { 729 var snapshot bytes.Buffer 730 io.Copy(&snapshot, ringBuffer) 731 err = &smithy.DeserializationError{ 732 Err: fmt.Errorf("failed to decode response body, %w", err), 733 Snapshot: snapshot.Bytes(), 734 } 735 return err 736 } 737 738 errorBody.Seek(0, io.SeekStart) 739 if len(code) != 0 { 740 errorCode = restjson.SanitizeErrorCode(code) 741 } 742 if len(message) != 0 { 743 errorMessage = message 744 } 745 746 switch { 747 case strings.EqualFold("ClusterNotFoundException", errorCode): 748 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 749 750 case strings.EqualFold("InvalidParameterException", errorCode): 751 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 752 753 case strings.EqualFold("TargetNotFoundException", errorCode): 754 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 755 756 default: 757 genericError := &smithy.GenericAPIError{ 758 Code: errorCode, 759 Message: errorMessage, 760 } 761 return genericError 762 763 } 764} 765 766type awsAwsjson11_deserializeOpDeleteCapacityProvider struct { 767} 768 769func (*awsAwsjson11_deserializeOpDeleteCapacityProvider) ID() string { 770 return "OperationDeserializer" 771} 772 773func (m *awsAwsjson11_deserializeOpDeleteCapacityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 774 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 775) { 776 out, metadata, err = next.HandleDeserialize(ctx, in) 777 if err != nil { 778 return out, metadata, err 779 } 780 781 response, ok := out.RawResponse.(*smithyhttp.Response) 782 if !ok { 783 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 784 } 785 786 if response.StatusCode < 200 || response.StatusCode >= 300 { 787 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(response, &metadata) 788 } 789 output := &DeleteCapacityProviderOutput{} 790 out.Result = output 791 792 var buff [1024]byte 793 ringBuffer := smithyio.NewRingBuffer(buff[:]) 794 795 body := io.TeeReader(response.Body, ringBuffer) 796 decoder := json.NewDecoder(body) 797 decoder.UseNumber() 798 var shape interface{} 799 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 800 var snapshot bytes.Buffer 801 io.Copy(&snapshot, ringBuffer) 802 err = &smithy.DeserializationError{ 803 Err: fmt.Errorf("failed to decode response body, %w", err), 804 Snapshot: snapshot.Bytes(), 805 } 806 return out, metadata, err 807 } 808 809 err = awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(&output, shape) 810 if err != nil { 811 var snapshot bytes.Buffer 812 io.Copy(&snapshot, ringBuffer) 813 err = &smithy.DeserializationError{ 814 Err: fmt.Errorf("failed to decode response body, %w", err), 815 Snapshot: snapshot.Bytes(), 816 } 817 return out, metadata, err 818 } 819 820 return out, metadata, err 821} 822 823func awsAwsjson11_deserializeOpErrorDeleteCapacityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { 824 var errorBuffer bytes.Buffer 825 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 826 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 827 } 828 errorBody := bytes.NewReader(errorBuffer.Bytes()) 829 830 errorCode := "UnknownError" 831 errorMessage := errorCode 832 833 code := response.Header.Get("X-Amzn-ErrorType") 834 if len(code) != 0 { 835 errorCode = restjson.SanitizeErrorCode(code) 836 } 837 838 var buff [1024]byte 839 ringBuffer := smithyio.NewRingBuffer(buff[:]) 840 841 body := io.TeeReader(errorBody, ringBuffer) 842 decoder := json.NewDecoder(body) 843 decoder.UseNumber() 844 code, message, err := restjson.GetErrorInfo(decoder) 845 if err != nil { 846 var snapshot bytes.Buffer 847 io.Copy(&snapshot, ringBuffer) 848 err = &smithy.DeserializationError{ 849 Err: fmt.Errorf("failed to decode response body, %w", err), 850 Snapshot: snapshot.Bytes(), 851 } 852 return err 853 } 854 855 errorBody.Seek(0, io.SeekStart) 856 if len(code) != 0 { 857 errorCode = restjson.SanitizeErrorCode(code) 858 } 859 if len(message) != 0 { 860 errorMessage = message 861 } 862 863 switch { 864 case strings.EqualFold("ClientException", errorCode): 865 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 866 867 case strings.EqualFold("InvalidParameterException", errorCode): 868 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 869 870 case strings.EqualFold("ServerException", errorCode): 871 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 872 873 default: 874 genericError := &smithy.GenericAPIError{ 875 Code: errorCode, 876 Message: errorMessage, 877 } 878 return genericError 879 880 } 881} 882 883type awsAwsjson11_deserializeOpDeleteCluster struct { 884} 885 886func (*awsAwsjson11_deserializeOpDeleteCluster) ID() string { 887 return "OperationDeserializer" 888} 889 890func (m *awsAwsjson11_deserializeOpDeleteCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 891 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 892) { 893 out, metadata, err = next.HandleDeserialize(ctx, in) 894 if err != nil { 895 return out, metadata, err 896 } 897 898 response, ok := out.RawResponse.(*smithyhttp.Response) 899 if !ok { 900 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 901 } 902 903 if response.StatusCode < 200 || response.StatusCode >= 300 { 904 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCluster(response, &metadata) 905 } 906 output := &DeleteClusterOutput{} 907 out.Result = output 908 909 var buff [1024]byte 910 ringBuffer := smithyio.NewRingBuffer(buff[:]) 911 912 body := io.TeeReader(response.Body, ringBuffer) 913 decoder := json.NewDecoder(body) 914 decoder.UseNumber() 915 var shape interface{} 916 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 917 var snapshot bytes.Buffer 918 io.Copy(&snapshot, ringBuffer) 919 err = &smithy.DeserializationError{ 920 Err: fmt.Errorf("failed to decode response body, %w", err), 921 Snapshot: snapshot.Bytes(), 922 } 923 return out, metadata, err 924 } 925 926 err = awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(&output, shape) 927 if err != nil { 928 var snapshot bytes.Buffer 929 io.Copy(&snapshot, ringBuffer) 930 err = &smithy.DeserializationError{ 931 Err: fmt.Errorf("failed to decode response body, %w", err), 932 Snapshot: snapshot.Bytes(), 933 } 934 return out, metadata, err 935 } 936 937 return out, metadata, err 938} 939 940func awsAwsjson11_deserializeOpErrorDeleteCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 941 var errorBuffer bytes.Buffer 942 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 943 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 944 } 945 errorBody := bytes.NewReader(errorBuffer.Bytes()) 946 947 errorCode := "UnknownError" 948 errorMessage := errorCode 949 950 code := response.Header.Get("X-Amzn-ErrorType") 951 if len(code) != 0 { 952 errorCode = restjson.SanitizeErrorCode(code) 953 } 954 955 var buff [1024]byte 956 ringBuffer := smithyio.NewRingBuffer(buff[:]) 957 958 body := io.TeeReader(errorBody, ringBuffer) 959 decoder := json.NewDecoder(body) 960 decoder.UseNumber() 961 code, message, err := restjson.GetErrorInfo(decoder) 962 if err != nil { 963 var snapshot bytes.Buffer 964 io.Copy(&snapshot, ringBuffer) 965 err = &smithy.DeserializationError{ 966 Err: fmt.Errorf("failed to decode response body, %w", err), 967 Snapshot: snapshot.Bytes(), 968 } 969 return err 970 } 971 972 errorBody.Seek(0, io.SeekStart) 973 if len(code) != 0 { 974 errorCode = restjson.SanitizeErrorCode(code) 975 } 976 if len(message) != 0 { 977 errorMessage = message 978 } 979 980 switch { 981 case strings.EqualFold("ClientException", errorCode): 982 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 983 984 case strings.EqualFold("ClusterContainsContainerInstancesException", errorCode): 985 return awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(response, errorBody) 986 987 case strings.EqualFold("ClusterContainsServicesException", errorCode): 988 return awsAwsjson11_deserializeErrorClusterContainsServicesException(response, errorBody) 989 990 case strings.EqualFold("ClusterContainsTasksException", errorCode): 991 return awsAwsjson11_deserializeErrorClusterContainsTasksException(response, errorBody) 992 993 case strings.EqualFold("ClusterNotFoundException", errorCode): 994 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 995 996 case strings.EqualFold("InvalidParameterException", errorCode): 997 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 998 999 case strings.EqualFold("ServerException", errorCode): 1000 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1001 1002 case strings.EqualFold("UpdateInProgressException", errorCode): 1003 return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody) 1004 1005 default: 1006 genericError := &smithy.GenericAPIError{ 1007 Code: errorCode, 1008 Message: errorMessage, 1009 } 1010 return genericError 1011 1012 } 1013} 1014 1015type awsAwsjson11_deserializeOpDeleteService struct { 1016} 1017 1018func (*awsAwsjson11_deserializeOpDeleteService) ID() string { 1019 return "OperationDeserializer" 1020} 1021 1022func (m *awsAwsjson11_deserializeOpDeleteService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1023 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1024) { 1025 out, metadata, err = next.HandleDeserialize(ctx, in) 1026 if err != nil { 1027 return out, metadata, err 1028 } 1029 1030 response, ok := out.RawResponse.(*smithyhttp.Response) 1031 if !ok { 1032 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1033 } 1034 1035 if response.StatusCode < 200 || response.StatusCode >= 300 { 1036 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteService(response, &metadata) 1037 } 1038 output := &DeleteServiceOutput{} 1039 out.Result = output 1040 1041 var buff [1024]byte 1042 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1043 1044 body := io.TeeReader(response.Body, ringBuffer) 1045 decoder := json.NewDecoder(body) 1046 decoder.UseNumber() 1047 var shape interface{} 1048 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1049 var snapshot bytes.Buffer 1050 io.Copy(&snapshot, ringBuffer) 1051 err = &smithy.DeserializationError{ 1052 Err: fmt.Errorf("failed to decode response body, %w", err), 1053 Snapshot: snapshot.Bytes(), 1054 } 1055 return out, metadata, err 1056 } 1057 1058 err = awsAwsjson11_deserializeOpDocumentDeleteServiceOutput(&output, shape) 1059 if err != nil { 1060 var snapshot bytes.Buffer 1061 io.Copy(&snapshot, ringBuffer) 1062 err = &smithy.DeserializationError{ 1063 Err: fmt.Errorf("failed to decode response body, %w", err), 1064 Snapshot: snapshot.Bytes(), 1065 } 1066 return out, metadata, err 1067 } 1068 1069 return out, metadata, err 1070} 1071 1072func awsAwsjson11_deserializeOpErrorDeleteService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1073 var errorBuffer bytes.Buffer 1074 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1075 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1076 } 1077 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1078 1079 errorCode := "UnknownError" 1080 errorMessage := errorCode 1081 1082 code := response.Header.Get("X-Amzn-ErrorType") 1083 if len(code) != 0 { 1084 errorCode = restjson.SanitizeErrorCode(code) 1085 } 1086 1087 var buff [1024]byte 1088 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1089 1090 body := io.TeeReader(errorBody, ringBuffer) 1091 decoder := json.NewDecoder(body) 1092 decoder.UseNumber() 1093 code, message, err := restjson.GetErrorInfo(decoder) 1094 if err != nil { 1095 var snapshot bytes.Buffer 1096 io.Copy(&snapshot, ringBuffer) 1097 err = &smithy.DeserializationError{ 1098 Err: fmt.Errorf("failed to decode response body, %w", err), 1099 Snapshot: snapshot.Bytes(), 1100 } 1101 return err 1102 } 1103 1104 errorBody.Seek(0, io.SeekStart) 1105 if len(code) != 0 { 1106 errorCode = restjson.SanitizeErrorCode(code) 1107 } 1108 if len(message) != 0 { 1109 errorMessage = message 1110 } 1111 1112 switch { 1113 case strings.EqualFold("ClientException", errorCode): 1114 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1115 1116 case strings.EqualFold("ClusterNotFoundException", errorCode): 1117 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 1118 1119 case strings.EqualFold("InvalidParameterException", errorCode): 1120 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1121 1122 case strings.EqualFold("ServerException", errorCode): 1123 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1124 1125 case strings.EqualFold("ServiceNotFoundException", errorCode): 1126 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 1127 1128 default: 1129 genericError := &smithy.GenericAPIError{ 1130 Code: errorCode, 1131 Message: errorMessage, 1132 } 1133 return genericError 1134 1135 } 1136} 1137 1138type awsAwsjson11_deserializeOpDeleteTaskSet struct { 1139} 1140 1141func (*awsAwsjson11_deserializeOpDeleteTaskSet) ID() string { 1142 return "OperationDeserializer" 1143} 1144 1145func (m *awsAwsjson11_deserializeOpDeleteTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1146 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1147) { 1148 out, metadata, err = next.HandleDeserialize(ctx, in) 1149 if err != nil { 1150 return out, metadata, err 1151 } 1152 1153 response, ok := out.RawResponse.(*smithyhttp.Response) 1154 if !ok { 1155 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1156 } 1157 1158 if response.StatusCode < 200 || response.StatusCode >= 300 { 1159 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTaskSet(response, &metadata) 1160 } 1161 output := &DeleteTaskSetOutput{} 1162 out.Result = output 1163 1164 var buff [1024]byte 1165 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1166 1167 body := io.TeeReader(response.Body, ringBuffer) 1168 decoder := json.NewDecoder(body) 1169 decoder.UseNumber() 1170 var shape interface{} 1171 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1172 var snapshot bytes.Buffer 1173 io.Copy(&snapshot, ringBuffer) 1174 err = &smithy.DeserializationError{ 1175 Err: fmt.Errorf("failed to decode response body, %w", err), 1176 Snapshot: snapshot.Bytes(), 1177 } 1178 return out, metadata, err 1179 } 1180 1181 err = awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(&output, shape) 1182 if err != nil { 1183 var snapshot bytes.Buffer 1184 io.Copy(&snapshot, ringBuffer) 1185 err = &smithy.DeserializationError{ 1186 Err: fmt.Errorf("failed to decode response body, %w", err), 1187 Snapshot: snapshot.Bytes(), 1188 } 1189 return out, metadata, err 1190 } 1191 1192 return out, metadata, err 1193} 1194 1195func awsAwsjson11_deserializeOpErrorDeleteTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1196 var errorBuffer bytes.Buffer 1197 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1198 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1199 } 1200 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1201 1202 errorCode := "UnknownError" 1203 errorMessage := errorCode 1204 1205 code := response.Header.Get("X-Amzn-ErrorType") 1206 if len(code) != 0 { 1207 errorCode = restjson.SanitizeErrorCode(code) 1208 } 1209 1210 var buff [1024]byte 1211 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1212 1213 body := io.TeeReader(errorBody, ringBuffer) 1214 decoder := json.NewDecoder(body) 1215 decoder.UseNumber() 1216 code, message, err := restjson.GetErrorInfo(decoder) 1217 if err != nil { 1218 var snapshot bytes.Buffer 1219 io.Copy(&snapshot, ringBuffer) 1220 err = &smithy.DeserializationError{ 1221 Err: fmt.Errorf("failed to decode response body, %w", err), 1222 Snapshot: snapshot.Bytes(), 1223 } 1224 return err 1225 } 1226 1227 errorBody.Seek(0, io.SeekStart) 1228 if len(code) != 0 { 1229 errorCode = restjson.SanitizeErrorCode(code) 1230 } 1231 if len(message) != 0 { 1232 errorMessage = message 1233 } 1234 1235 switch { 1236 case strings.EqualFold("AccessDeniedException", errorCode): 1237 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1238 1239 case strings.EqualFold("ClientException", errorCode): 1240 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1241 1242 case strings.EqualFold("ClusterNotFoundException", errorCode): 1243 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 1244 1245 case strings.EqualFold("InvalidParameterException", errorCode): 1246 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1247 1248 case strings.EqualFold("ServerException", errorCode): 1249 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1250 1251 case strings.EqualFold("ServiceNotActiveException", errorCode): 1252 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 1253 1254 case strings.EqualFold("ServiceNotFoundException", errorCode): 1255 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 1256 1257 case strings.EqualFold("TaskSetNotFoundException", errorCode): 1258 return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody) 1259 1260 case strings.EqualFold("UnsupportedFeatureException", errorCode): 1261 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 1262 1263 default: 1264 genericError := &smithy.GenericAPIError{ 1265 Code: errorCode, 1266 Message: errorMessage, 1267 } 1268 return genericError 1269 1270 } 1271} 1272 1273type awsAwsjson11_deserializeOpDeregisterContainerInstance struct { 1274} 1275 1276func (*awsAwsjson11_deserializeOpDeregisterContainerInstance) ID() string { 1277 return "OperationDeserializer" 1278} 1279 1280func (m *awsAwsjson11_deserializeOpDeregisterContainerInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1281 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 out, metadata, err = next.HandleDeserialize(ctx, in) 1284 if err != nil { 1285 return out, metadata, err 1286 } 1287 1288 response, ok := out.RawResponse.(*smithyhttp.Response) 1289 if !ok { 1290 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1291 } 1292 1293 if response.StatusCode < 200 || response.StatusCode >= 300 { 1294 return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(response, &metadata) 1295 } 1296 output := &DeregisterContainerInstanceOutput{} 1297 out.Result = output 1298 1299 var buff [1024]byte 1300 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1301 1302 body := io.TeeReader(response.Body, ringBuffer) 1303 decoder := json.NewDecoder(body) 1304 decoder.UseNumber() 1305 var shape interface{} 1306 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1307 var snapshot bytes.Buffer 1308 io.Copy(&snapshot, ringBuffer) 1309 err = &smithy.DeserializationError{ 1310 Err: fmt.Errorf("failed to decode response body, %w", err), 1311 Snapshot: snapshot.Bytes(), 1312 } 1313 return out, metadata, err 1314 } 1315 1316 err = awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(&output, shape) 1317 if err != nil { 1318 var snapshot bytes.Buffer 1319 io.Copy(&snapshot, ringBuffer) 1320 err = &smithy.DeserializationError{ 1321 Err: fmt.Errorf("failed to decode response body, %w", err), 1322 Snapshot: snapshot.Bytes(), 1323 } 1324 return out, metadata, err 1325 } 1326 1327 return out, metadata, err 1328} 1329 1330func awsAwsjson11_deserializeOpErrorDeregisterContainerInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1331 var errorBuffer bytes.Buffer 1332 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1333 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1334 } 1335 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1336 1337 errorCode := "UnknownError" 1338 errorMessage := errorCode 1339 1340 code := response.Header.Get("X-Amzn-ErrorType") 1341 if len(code) != 0 { 1342 errorCode = restjson.SanitizeErrorCode(code) 1343 } 1344 1345 var buff [1024]byte 1346 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1347 1348 body := io.TeeReader(errorBody, ringBuffer) 1349 decoder := json.NewDecoder(body) 1350 decoder.UseNumber() 1351 code, message, err := restjson.GetErrorInfo(decoder) 1352 if err != nil { 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 err 1360 } 1361 1362 errorBody.Seek(0, io.SeekStart) 1363 if len(code) != 0 { 1364 errorCode = restjson.SanitizeErrorCode(code) 1365 } 1366 if len(message) != 0 { 1367 errorMessage = message 1368 } 1369 1370 switch { 1371 case strings.EqualFold("ClientException", errorCode): 1372 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1373 1374 case strings.EqualFold("ClusterNotFoundException", errorCode): 1375 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 1376 1377 case strings.EqualFold("InvalidParameterException", errorCode): 1378 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1379 1380 case strings.EqualFold("ServerException", errorCode): 1381 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1382 1383 default: 1384 genericError := &smithy.GenericAPIError{ 1385 Code: errorCode, 1386 Message: errorMessage, 1387 } 1388 return genericError 1389 1390 } 1391} 1392 1393type awsAwsjson11_deserializeOpDeregisterTaskDefinition struct { 1394} 1395 1396func (*awsAwsjson11_deserializeOpDeregisterTaskDefinition) ID() string { 1397 return "OperationDeserializer" 1398} 1399 1400func (m *awsAwsjson11_deserializeOpDeregisterTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1401 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 out, metadata, err = next.HandleDeserialize(ctx, in) 1404 if err != nil { 1405 return out, metadata, err 1406 } 1407 1408 response, ok := out.RawResponse.(*smithyhttp.Response) 1409 if !ok { 1410 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1411 } 1412 1413 if response.StatusCode < 200 || response.StatusCode >= 300 { 1414 return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(response, &metadata) 1415 } 1416 output := &DeregisterTaskDefinitionOutput{} 1417 out.Result = output 1418 1419 var buff [1024]byte 1420 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1421 1422 body := io.TeeReader(response.Body, ringBuffer) 1423 decoder := json.NewDecoder(body) 1424 decoder.UseNumber() 1425 var shape interface{} 1426 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1427 var snapshot bytes.Buffer 1428 io.Copy(&snapshot, ringBuffer) 1429 err = &smithy.DeserializationError{ 1430 Err: fmt.Errorf("failed to decode response body, %w", err), 1431 Snapshot: snapshot.Bytes(), 1432 } 1433 return out, metadata, err 1434 } 1435 1436 err = awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(&output, shape) 1437 if err != nil { 1438 var snapshot bytes.Buffer 1439 io.Copy(&snapshot, ringBuffer) 1440 err = &smithy.DeserializationError{ 1441 Err: fmt.Errorf("failed to decode response body, %w", err), 1442 Snapshot: snapshot.Bytes(), 1443 } 1444 return out, metadata, err 1445 } 1446 1447 return out, metadata, err 1448} 1449 1450func awsAwsjson11_deserializeOpErrorDeregisterTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1451 var errorBuffer bytes.Buffer 1452 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1453 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1454 } 1455 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1456 1457 errorCode := "UnknownError" 1458 errorMessage := errorCode 1459 1460 code := response.Header.Get("X-Amzn-ErrorType") 1461 if len(code) != 0 { 1462 errorCode = restjson.SanitizeErrorCode(code) 1463 } 1464 1465 var buff [1024]byte 1466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1467 1468 body := io.TeeReader(errorBody, ringBuffer) 1469 decoder := json.NewDecoder(body) 1470 decoder.UseNumber() 1471 code, message, err := restjson.GetErrorInfo(decoder) 1472 if err != nil { 1473 var snapshot bytes.Buffer 1474 io.Copy(&snapshot, ringBuffer) 1475 err = &smithy.DeserializationError{ 1476 Err: fmt.Errorf("failed to decode response body, %w", err), 1477 Snapshot: snapshot.Bytes(), 1478 } 1479 return err 1480 } 1481 1482 errorBody.Seek(0, io.SeekStart) 1483 if len(code) != 0 { 1484 errorCode = restjson.SanitizeErrorCode(code) 1485 } 1486 if len(message) != 0 { 1487 errorMessage = message 1488 } 1489 1490 switch { 1491 case strings.EqualFold("ClientException", errorCode): 1492 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1493 1494 case strings.EqualFold("InvalidParameterException", errorCode): 1495 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1496 1497 case strings.EqualFold("ServerException", errorCode): 1498 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1499 1500 default: 1501 genericError := &smithy.GenericAPIError{ 1502 Code: errorCode, 1503 Message: errorMessage, 1504 } 1505 return genericError 1506 1507 } 1508} 1509 1510type awsAwsjson11_deserializeOpDescribeCapacityProviders struct { 1511} 1512 1513func (*awsAwsjson11_deserializeOpDescribeCapacityProviders) ID() string { 1514 return "OperationDeserializer" 1515} 1516 1517func (m *awsAwsjson11_deserializeOpDescribeCapacityProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1519) { 1520 out, metadata, err = next.HandleDeserialize(ctx, in) 1521 if err != nil { 1522 return out, metadata, err 1523 } 1524 1525 response, ok := out.RawResponse.(*smithyhttp.Response) 1526 if !ok { 1527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1528 } 1529 1530 if response.StatusCode < 200 || response.StatusCode >= 300 { 1531 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(response, &metadata) 1532 } 1533 output := &DescribeCapacityProvidersOutput{} 1534 out.Result = output 1535 1536 var buff [1024]byte 1537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1538 1539 body := io.TeeReader(response.Body, ringBuffer) 1540 decoder := json.NewDecoder(body) 1541 decoder.UseNumber() 1542 var shape interface{} 1543 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1544 var snapshot bytes.Buffer 1545 io.Copy(&snapshot, ringBuffer) 1546 err = &smithy.DeserializationError{ 1547 Err: fmt.Errorf("failed to decode response body, %w", err), 1548 Snapshot: snapshot.Bytes(), 1549 } 1550 return out, metadata, err 1551 } 1552 1553 err = awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(&output, shape) 1554 if err != nil { 1555 var snapshot bytes.Buffer 1556 io.Copy(&snapshot, ringBuffer) 1557 err = &smithy.DeserializationError{ 1558 Err: fmt.Errorf("failed to decode response body, %w", err), 1559 Snapshot: snapshot.Bytes(), 1560 } 1561 return out, metadata, err 1562 } 1563 1564 return out, metadata, err 1565} 1566 1567func awsAwsjson11_deserializeOpErrorDescribeCapacityProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1568 var errorBuffer bytes.Buffer 1569 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1570 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1571 } 1572 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1573 1574 errorCode := "UnknownError" 1575 errorMessage := errorCode 1576 1577 code := response.Header.Get("X-Amzn-ErrorType") 1578 if len(code) != 0 { 1579 errorCode = restjson.SanitizeErrorCode(code) 1580 } 1581 1582 var buff [1024]byte 1583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1584 1585 body := io.TeeReader(errorBody, ringBuffer) 1586 decoder := json.NewDecoder(body) 1587 decoder.UseNumber() 1588 code, message, err := restjson.GetErrorInfo(decoder) 1589 if err != nil { 1590 var snapshot bytes.Buffer 1591 io.Copy(&snapshot, ringBuffer) 1592 err = &smithy.DeserializationError{ 1593 Err: fmt.Errorf("failed to decode response body, %w", err), 1594 Snapshot: snapshot.Bytes(), 1595 } 1596 return err 1597 } 1598 1599 errorBody.Seek(0, io.SeekStart) 1600 if len(code) != 0 { 1601 errorCode = restjson.SanitizeErrorCode(code) 1602 } 1603 if len(message) != 0 { 1604 errorMessage = message 1605 } 1606 1607 switch { 1608 case strings.EqualFold("ClientException", errorCode): 1609 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1610 1611 case strings.EqualFold("InvalidParameterException", errorCode): 1612 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1613 1614 case strings.EqualFold("ServerException", errorCode): 1615 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1616 1617 default: 1618 genericError := &smithy.GenericAPIError{ 1619 Code: errorCode, 1620 Message: errorMessage, 1621 } 1622 return genericError 1623 1624 } 1625} 1626 1627type awsAwsjson11_deserializeOpDescribeClusters struct { 1628} 1629 1630func (*awsAwsjson11_deserializeOpDescribeClusters) ID() string { 1631 return "OperationDeserializer" 1632} 1633 1634func (m *awsAwsjson11_deserializeOpDescribeClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1636) { 1637 out, metadata, err = next.HandleDeserialize(ctx, in) 1638 if err != nil { 1639 return out, metadata, err 1640 } 1641 1642 response, ok := out.RawResponse.(*smithyhttp.Response) 1643 if !ok { 1644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1645 } 1646 1647 if response.StatusCode < 200 || response.StatusCode >= 300 { 1648 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeClusters(response, &metadata) 1649 } 1650 output := &DescribeClustersOutput{} 1651 out.Result = output 1652 1653 var buff [1024]byte 1654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1655 1656 body := io.TeeReader(response.Body, ringBuffer) 1657 decoder := json.NewDecoder(body) 1658 decoder.UseNumber() 1659 var shape interface{} 1660 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1661 var snapshot bytes.Buffer 1662 io.Copy(&snapshot, ringBuffer) 1663 err = &smithy.DeserializationError{ 1664 Err: fmt.Errorf("failed to decode response body, %w", err), 1665 Snapshot: snapshot.Bytes(), 1666 } 1667 return out, metadata, err 1668 } 1669 1670 err = awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(&output, shape) 1671 if err != nil { 1672 var snapshot bytes.Buffer 1673 io.Copy(&snapshot, ringBuffer) 1674 err = &smithy.DeserializationError{ 1675 Err: fmt.Errorf("failed to decode response body, %w", err), 1676 Snapshot: snapshot.Bytes(), 1677 } 1678 return out, metadata, err 1679 } 1680 1681 return out, metadata, err 1682} 1683 1684func awsAwsjson11_deserializeOpErrorDescribeClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1685 var errorBuffer bytes.Buffer 1686 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1687 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1688 } 1689 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1690 1691 errorCode := "UnknownError" 1692 errorMessage := errorCode 1693 1694 code := response.Header.Get("X-Amzn-ErrorType") 1695 if len(code) != 0 { 1696 errorCode = restjson.SanitizeErrorCode(code) 1697 } 1698 1699 var buff [1024]byte 1700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1701 1702 body := io.TeeReader(errorBody, ringBuffer) 1703 decoder := json.NewDecoder(body) 1704 decoder.UseNumber() 1705 code, message, err := restjson.GetErrorInfo(decoder) 1706 if err != nil { 1707 var snapshot bytes.Buffer 1708 io.Copy(&snapshot, ringBuffer) 1709 err = &smithy.DeserializationError{ 1710 Err: fmt.Errorf("failed to decode response body, %w", err), 1711 Snapshot: snapshot.Bytes(), 1712 } 1713 return err 1714 } 1715 1716 errorBody.Seek(0, io.SeekStart) 1717 if len(code) != 0 { 1718 errorCode = restjson.SanitizeErrorCode(code) 1719 } 1720 if len(message) != 0 { 1721 errorMessage = message 1722 } 1723 1724 switch { 1725 case strings.EqualFold("ClientException", errorCode): 1726 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1727 1728 case strings.EqualFold("InvalidParameterException", errorCode): 1729 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1730 1731 case strings.EqualFold("ServerException", errorCode): 1732 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1733 1734 default: 1735 genericError := &smithy.GenericAPIError{ 1736 Code: errorCode, 1737 Message: errorMessage, 1738 } 1739 return genericError 1740 1741 } 1742} 1743 1744type awsAwsjson11_deserializeOpDescribeContainerInstances struct { 1745} 1746 1747func (*awsAwsjson11_deserializeOpDescribeContainerInstances) ID() string { 1748 return "OperationDeserializer" 1749} 1750 1751func (m *awsAwsjson11_deserializeOpDescribeContainerInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1752 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1753) { 1754 out, metadata, err = next.HandleDeserialize(ctx, in) 1755 if err != nil { 1756 return out, metadata, err 1757 } 1758 1759 response, ok := out.RawResponse.(*smithyhttp.Response) 1760 if !ok { 1761 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1762 } 1763 1764 if response.StatusCode < 200 || response.StatusCode >= 300 { 1765 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeContainerInstances(response, &metadata) 1766 } 1767 output := &DescribeContainerInstancesOutput{} 1768 out.Result = output 1769 1770 var buff [1024]byte 1771 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1772 1773 body := io.TeeReader(response.Body, ringBuffer) 1774 decoder := json.NewDecoder(body) 1775 decoder.UseNumber() 1776 var shape interface{} 1777 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1778 var snapshot bytes.Buffer 1779 io.Copy(&snapshot, ringBuffer) 1780 err = &smithy.DeserializationError{ 1781 Err: fmt.Errorf("failed to decode response body, %w", err), 1782 Snapshot: snapshot.Bytes(), 1783 } 1784 return out, metadata, err 1785 } 1786 1787 err = awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(&output, shape) 1788 if err != nil { 1789 var snapshot bytes.Buffer 1790 io.Copy(&snapshot, ringBuffer) 1791 err = &smithy.DeserializationError{ 1792 Err: fmt.Errorf("failed to decode response body, %w", err), 1793 Snapshot: snapshot.Bytes(), 1794 } 1795 return out, metadata, err 1796 } 1797 1798 return out, metadata, err 1799} 1800 1801func awsAwsjson11_deserializeOpErrorDescribeContainerInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1802 var errorBuffer bytes.Buffer 1803 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1804 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1805 } 1806 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1807 1808 errorCode := "UnknownError" 1809 errorMessage := errorCode 1810 1811 code := response.Header.Get("X-Amzn-ErrorType") 1812 if len(code) != 0 { 1813 errorCode = restjson.SanitizeErrorCode(code) 1814 } 1815 1816 var buff [1024]byte 1817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1818 1819 body := io.TeeReader(errorBody, ringBuffer) 1820 decoder := json.NewDecoder(body) 1821 decoder.UseNumber() 1822 code, message, err := restjson.GetErrorInfo(decoder) 1823 if err != nil { 1824 var snapshot bytes.Buffer 1825 io.Copy(&snapshot, ringBuffer) 1826 err = &smithy.DeserializationError{ 1827 Err: fmt.Errorf("failed to decode response body, %w", err), 1828 Snapshot: snapshot.Bytes(), 1829 } 1830 return err 1831 } 1832 1833 errorBody.Seek(0, io.SeekStart) 1834 if len(code) != 0 { 1835 errorCode = restjson.SanitizeErrorCode(code) 1836 } 1837 if len(message) != 0 { 1838 errorMessage = message 1839 } 1840 1841 switch { 1842 case strings.EqualFold("ClientException", errorCode): 1843 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1844 1845 case strings.EqualFold("ClusterNotFoundException", errorCode): 1846 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 1847 1848 case strings.EqualFold("InvalidParameterException", errorCode): 1849 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1850 1851 case strings.EqualFold("ServerException", errorCode): 1852 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1853 1854 default: 1855 genericError := &smithy.GenericAPIError{ 1856 Code: errorCode, 1857 Message: errorMessage, 1858 } 1859 return genericError 1860 1861 } 1862} 1863 1864type awsAwsjson11_deserializeOpDescribeServices struct { 1865} 1866 1867func (*awsAwsjson11_deserializeOpDescribeServices) ID() string { 1868 return "OperationDeserializer" 1869} 1870 1871func (m *awsAwsjson11_deserializeOpDescribeServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1872 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1873) { 1874 out, metadata, err = next.HandleDeserialize(ctx, in) 1875 if err != nil { 1876 return out, metadata, err 1877 } 1878 1879 response, ok := out.RawResponse.(*smithyhttp.Response) 1880 if !ok { 1881 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1882 } 1883 1884 if response.StatusCode < 200 || response.StatusCode >= 300 { 1885 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServices(response, &metadata) 1886 } 1887 output := &DescribeServicesOutput{} 1888 out.Result = output 1889 1890 var buff [1024]byte 1891 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1892 1893 body := io.TeeReader(response.Body, ringBuffer) 1894 decoder := json.NewDecoder(body) 1895 decoder.UseNumber() 1896 var shape interface{} 1897 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1898 var snapshot bytes.Buffer 1899 io.Copy(&snapshot, ringBuffer) 1900 err = &smithy.DeserializationError{ 1901 Err: fmt.Errorf("failed to decode response body, %w", err), 1902 Snapshot: snapshot.Bytes(), 1903 } 1904 return out, metadata, err 1905 } 1906 1907 err = awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(&output, shape) 1908 if err != nil { 1909 var snapshot bytes.Buffer 1910 io.Copy(&snapshot, ringBuffer) 1911 err = &smithy.DeserializationError{ 1912 Err: fmt.Errorf("failed to decode response body, %w", err), 1913 Snapshot: snapshot.Bytes(), 1914 } 1915 return out, metadata, err 1916 } 1917 1918 return out, metadata, err 1919} 1920 1921func awsAwsjson11_deserializeOpErrorDescribeServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1922 var errorBuffer bytes.Buffer 1923 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1924 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1925 } 1926 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1927 1928 errorCode := "UnknownError" 1929 errorMessage := errorCode 1930 1931 code := response.Header.Get("X-Amzn-ErrorType") 1932 if len(code) != 0 { 1933 errorCode = restjson.SanitizeErrorCode(code) 1934 } 1935 1936 var buff [1024]byte 1937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1938 1939 body := io.TeeReader(errorBody, ringBuffer) 1940 decoder := json.NewDecoder(body) 1941 decoder.UseNumber() 1942 code, message, err := restjson.GetErrorInfo(decoder) 1943 if err != nil { 1944 var snapshot bytes.Buffer 1945 io.Copy(&snapshot, ringBuffer) 1946 err = &smithy.DeserializationError{ 1947 Err: fmt.Errorf("failed to decode response body, %w", err), 1948 Snapshot: snapshot.Bytes(), 1949 } 1950 return err 1951 } 1952 1953 errorBody.Seek(0, io.SeekStart) 1954 if len(code) != 0 { 1955 errorCode = restjson.SanitizeErrorCode(code) 1956 } 1957 if len(message) != 0 { 1958 errorMessage = message 1959 } 1960 1961 switch { 1962 case strings.EqualFold("ClientException", errorCode): 1963 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 1964 1965 case strings.EqualFold("ClusterNotFoundException", errorCode): 1966 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 1967 1968 case strings.EqualFold("InvalidParameterException", errorCode): 1969 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1970 1971 case strings.EqualFold("ServerException", errorCode): 1972 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 1973 1974 default: 1975 genericError := &smithy.GenericAPIError{ 1976 Code: errorCode, 1977 Message: errorMessage, 1978 } 1979 return genericError 1980 1981 } 1982} 1983 1984type awsAwsjson11_deserializeOpDescribeTaskDefinition struct { 1985} 1986 1987func (*awsAwsjson11_deserializeOpDescribeTaskDefinition) ID() string { 1988 return "OperationDeserializer" 1989} 1990 1991func (m *awsAwsjson11_deserializeOpDescribeTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1992 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1993) { 1994 out, metadata, err = next.HandleDeserialize(ctx, in) 1995 if err != nil { 1996 return out, metadata, err 1997 } 1998 1999 response, ok := out.RawResponse.(*smithyhttp.Response) 2000 if !ok { 2001 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2002 } 2003 2004 if response.StatusCode < 200 || response.StatusCode >= 300 { 2005 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(response, &metadata) 2006 } 2007 output := &DescribeTaskDefinitionOutput{} 2008 out.Result = output 2009 2010 var buff [1024]byte 2011 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2012 2013 body := io.TeeReader(response.Body, ringBuffer) 2014 decoder := json.NewDecoder(body) 2015 decoder.UseNumber() 2016 var shape interface{} 2017 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2018 var snapshot bytes.Buffer 2019 io.Copy(&snapshot, ringBuffer) 2020 err = &smithy.DeserializationError{ 2021 Err: fmt.Errorf("failed to decode response body, %w", err), 2022 Snapshot: snapshot.Bytes(), 2023 } 2024 return out, metadata, err 2025 } 2026 2027 err = awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(&output, shape) 2028 if err != nil { 2029 var snapshot bytes.Buffer 2030 io.Copy(&snapshot, ringBuffer) 2031 err = &smithy.DeserializationError{ 2032 Err: fmt.Errorf("failed to decode response body, %w", err), 2033 Snapshot: snapshot.Bytes(), 2034 } 2035 return out, metadata, err 2036 } 2037 2038 return out, metadata, err 2039} 2040 2041func awsAwsjson11_deserializeOpErrorDescribeTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2042 var errorBuffer bytes.Buffer 2043 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2044 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2045 } 2046 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2047 2048 errorCode := "UnknownError" 2049 errorMessage := errorCode 2050 2051 code := response.Header.Get("X-Amzn-ErrorType") 2052 if len(code) != 0 { 2053 errorCode = restjson.SanitizeErrorCode(code) 2054 } 2055 2056 var buff [1024]byte 2057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2058 2059 body := io.TeeReader(errorBody, ringBuffer) 2060 decoder := json.NewDecoder(body) 2061 decoder.UseNumber() 2062 code, message, err := restjson.GetErrorInfo(decoder) 2063 if err != nil { 2064 var snapshot bytes.Buffer 2065 io.Copy(&snapshot, ringBuffer) 2066 err = &smithy.DeserializationError{ 2067 Err: fmt.Errorf("failed to decode response body, %w", err), 2068 Snapshot: snapshot.Bytes(), 2069 } 2070 return err 2071 } 2072 2073 errorBody.Seek(0, io.SeekStart) 2074 if len(code) != 0 { 2075 errorCode = restjson.SanitizeErrorCode(code) 2076 } 2077 if len(message) != 0 { 2078 errorMessage = message 2079 } 2080 2081 switch { 2082 case strings.EqualFold("ClientException", errorCode): 2083 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2084 2085 case strings.EqualFold("InvalidParameterException", errorCode): 2086 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2087 2088 case strings.EqualFold("ServerException", errorCode): 2089 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2090 2091 default: 2092 genericError := &smithy.GenericAPIError{ 2093 Code: errorCode, 2094 Message: errorMessage, 2095 } 2096 return genericError 2097 2098 } 2099} 2100 2101type awsAwsjson11_deserializeOpDescribeTasks struct { 2102} 2103 2104func (*awsAwsjson11_deserializeOpDescribeTasks) ID() string { 2105 return "OperationDeserializer" 2106} 2107 2108func (m *awsAwsjson11_deserializeOpDescribeTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2109 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2110) { 2111 out, metadata, err = next.HandleDeserialize(ctx, in) 2112 if err != nil { 2113 return out, metadata, err 2114 } 2115 2116 response, ok := out.RawResponse.(*smithyhttp.Response) 2117 if !ok { 2118 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2119 } 2120 2121 if response.StatusCode < 200 || response.StatusCode >= 300 { 2122 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTasks(response, &metadata) 2123 } 2124 output := &DescribeTasksOutput{} 2125 out.Result = output 2126 2127 var buff [1024]byte 2128 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2129 2130 body := io.TeeReader(response.Body, ringBuffer) 2131 decoder := json.NewDecoder(body) 2132 decoder.UseNumber() 2133 var shape interface{} 2134 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2135 var snapshot bytes.Buffer 2136 io.Copy(&snapshot, ringBuffer) 2137 err = &smithy.DeserializationError{ 2138 Err: fmt.Errorf("failed to decode response body, %w", err), 2139 Snapshot: snapshot.Bytes(), 2140 } 2141 return out, metadata, err 2142 } 2143 2144 err = awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(&output, shape) 2145 if err != nil { 2146 var snapshot bytes.Buffer 2147 io.Copy(&snapshot, ringBuffer) 2148 err = &smithy.DeserializationError{ 2149 Err: fmt.Errorf("failed to decode response body, %w", err), 2150 Snapshot: snapshot.Bytes(), 2151 } 2152 return out, metadata, err 2153 } 2154 2155 return out, metadata, err 2156} 2157 2158func awsAwsjson11_deserializeOpErrorDescribeTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2159 var errorBuffer bytes.Buffer 2160 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2161 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2162 } 2163 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2164 2165 errorCode := "UnknownError" 2166 errorMessage := errorCode 2167 2168 code := response.Header.Get("X-Amzn-ErrorType") 2169 if len(code) != 0 { 2170 errorCode = restjson.SanitizeErrorCode(code) 2171 } 2172 2173 var buff [1024]byte 2174 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2175 2176 body := io.TeeReader(errorBody, ringBuffer) 2177 decoder := json.NewDecoder(body) 2178 decoder.UseNumber() 2179 code, message, err := restjson.GetErrorInfo(decoder) 2180 if err != nil { 2181 var snapshot bytes.Buffer 2182 io.Copy(&snapshot, ringBuffer) 2183 err = &smithy.DeserializationError{ 2184 Err: fmt.Errorf("failed to decode response body, %w", err), 2185 Snapshot: snapshot.Bytes(), 2186 } 2187 return err 2188 } 2189 2190 errorBody.Seek(0, io.SeekStart) 2191 if len(code) != 0 { 2192 errorCode = restjson.SanitizeErrorCode(code) 2193 } 2194 if len(message) != 0 { 2195 errorMessage = message 2196 } 2197 2198 switch { 2199 case strings.EqualFold("ClientException", errorCode): 2200 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2201 2202 case strings.EqualFold("ClusterNotFoundException", errorCode): 2203 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 2204 2205 case strings.EqualFold("InvalidParameterException", errorCode): 2206 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2207 2208 case strings.EqualFold("ServerException", errorCode): 2209 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2210 2211 default: 2212 genericError := &smithy.GenericAPIError{ 2213 Code: errorCode, 2214 Message: errorMessage, 2215 } 2216 return genericError 2217 2218 } 2219} 2220 2221type awsAwsjson11_deserializeOpDescribeTaskSets struct { 2222} 2223 2224func (*awsAwsjson11_deserializeOpDescribeTaskSets) ID() string { 2225 return "OperationDeserializer" 2226} 2227 2228func (m *awsAwsjson11_deserializeOpDescribeTaskSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2229 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2230) { 2231 out, metadata, err = next.HandleDeserialize(ctx, in) 2232 if err != nil { 2233 return out, metadata, err 2234 } 2235 2236 response, ok := out.RawResponse.(*smithyhttp.Response) 2237 if !ok { 2238 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2239 } 2240 2241 if response.StatusCode < 200 || response.StatusCode >= 300 { 2242 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTaskSets(response, &metadata) 2243 } 2244 output := &DescribeTaskSetsOutput{} 2245 out.Result = output 2246 2247 var buff [1024]byte 2248 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2249 2250 body := io.TeeReader(response.Body, ringBuffer) 2251 decoder := json.NewDecoder(body) 2252 decoder.UseNumber() 2253 var shape interface{} 2254 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2255 var snapshot bytes.Buffer 2256 io.Copy(&snapshot, ringBuffer) 2257 err = &smithy.DeserializationError{ 2258 Err: fmt.Errorf("failed to decode response body, %w", err), 2259 Snapshot: snapshot.Bytes(), 2260 } 2261 return out, metadata, err 2262 } 2263 2264 err = awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(&output, shape) 2265 if err != nil { 2266 var snapshot bytes.Buffer 2267 io.Copy(&snapshot, ringBuffer) 2268 err = &smithy.DeserializationError{ 2269 Err: fmt.Errorf("failed to decode response body, %w", err), 2270 Snapshot: snapshot.Bytes(), 2271 } 2272 return out, metadata, err 2273 } 2274 2275 return out, metadata, err 2276} 2277 2278func awsAwsjson11_deserializeOpErrorDescribeTaskSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2279 var errorBuffer bytes.Buffer 2280 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2281 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2282 } 2283 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2284 2285 errorCode := "UnknownError" 2286 errorMessage := errorCode 2287 2288 code := response.Header.Get("X-Amzn-ErrorType") 2289 if len(code) != 0 { 2290 errorCode = restjson.SanitizeErrorCode(code) 2291 } 2292 2293 var buff [1024]byte 2294 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2295 2296 body := io.TeeReader(errorBody, ringBuffer) 2297 decoder := json.NewDecoder(body) 2298 decoder.UseNumber() 2299 code, message, err := restjson.GetErrorInfo(decoder) 2300 if err != nil { 2301 var snapshot bytes.Buffer 2302 io.Copy(&snapshot, ringBuffer) 2303 err = &smithy.DeserializationError{ 2304 Err: fmt.Errorf("failed to decode response body, %w", err), 2305 Snapshot: snapshot.Bytes(), 2306 } 2307 return err 2308 } 2309 2310 errorBody.Seek(0, io.SeekStart) 2311 if len(code) != 0 { 2312 errorCode = restjson.SanitizeErrorCode(code) 2313 } 2314 if len(message) != 0 { 2315 errorMessage = message 2316 } 2317 2318 switch { 2319 case strings.EqualFold("AccessDeniedException", errorCode): 2320 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2321 2322 case strings.EqualFold("ClientException", errorCode): 2323 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2324 2325 case strings.EqualFold("ClusterNotFoundException", errorCode): 2326 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 2327 2328 case strings.EqualFold("InvalidParameterException", errorCode): 2329 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2330 2331 case strings.EqualFold("ServerException", errorCode): 2332 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2333 2334 case strings.EqualFold("ServiceNotActiveException", errorCode): 2335 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 2336 2337 case strings.EqualFold("ServiceNotFoundException", errorCode): 2338 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 2339 2340 case strings.EqualFold("UnsupportedFeatureException", errorCode): 2341 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 2342 2343 default: 2344 genericError := &smithy.GenericAPIError{ 2345 Code: errorCode, 2346 Message: errorMessage, 2347 } 2348 return genericError 2349 2350 } 2351} 2352 2353type awsAwsjson11_deserializeOpDiscoverPollEndpoint struct { 2354} 2355 2356func (*awsAwsjson11_deserializeOpDiscoverPollEndpoint) ID() string { 2357 return "OperationDeserializer" 2358} 2359 2360func (m *awsAwsjson11_deserializeOpDiscoverPollEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2361 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2362) { 2363 out, metadata, err = next.HandleDeserialize(ctx, in) 2364 if err != nil { 2365 return out, metadata, err 2366 } 2367 2368 response, ok := out.RawResponse.(*smithyhttp.Response) 2369 if !ok { 2370 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2371 } 2372 2373 if response.StatusCode < 200 || response.StatusCode >= 300 { 2374 return out, metadata, awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(response, &metadata) 2375 } 2376 output := &DiscoverPollEndpointOutput{} 2377 out.Result = output 2378 2379 var buff [1024]byte 2380 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2381 2382 body := io.TeeReader(response.Body, ringBuffer) 2383 decoder := json.NewDecoder(body) 2384 decoder.UseNumber() 2385 var shape interface{} 2386 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2387 var snapshot bytes.Buffer 2388 io.Copy(&snapshot, ringBuffer) 2389 err = &smithy.DeserializationError{ 2390 Err: fmt.Errorf("failed to decode response body, %w", err), 2391 Snapshot: snapshot.Bytes(), 2392 } 2393 return out, metadata, err 2394 } 2395 2396 err = awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(&output, shape) 2397 if err != nil { 2398 var snapshot bytes.Buffer 2399 io.Copy(&snapshot, ringBuffer) 2400 err = &smithy.DeserializationError{ 2401 Err: fmt.Errorf("failed to decode response body, %w", err), 2402 Snapshot: snapshot.Bytes(), 2403 } 2404 return out, metadata, err 2405 } 2406 2407 return out, metadata, err 2408} 2409 2410func awsAwsjson11_deserializeOpErrorDiscoverPollEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2411 var errorBuffer bytes.Buffer 2412 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2413 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2414 } 2415 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2416 2417 errorCode := "UnknownError" 2418 errorMessage := errorCode 2419 2420 code := response.Header.Get("X-Amzn-ErrorType") 2421 if len(code) != 0 { 2422 errorCode = restjson.SanitizeErrorCode(code) 2423 } 2424 2425 var buff [1024]byte 2426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2427 2428 body := io.TeeReader(errorBody, ringBuffer) 2429 decoder := json.NewDecoder(body) 2430 decoder.UseNumber() 2431 code, message, err := restjson.GetErrorInfo(decoder) 2432 if err != nil { 2433 var snapshot bytes.Buffer 2434 io.Copy(&snapshot, ringBuffer) 2435 err = &smithy.DeserializationError{ 2436 Err: fmt.Errorf("failed to decode response body, %w", err), 2437 Snapshot: snapshot.Bytes(), 2438 } 2439 return err 2440 } 2441 2442 errorBody.Seek(0, io.SeekStart) 2443 if len(code) != 0 { 2444 errorCode = restjson.SanitizeErrorCode(code) 2445 } 2446 if len(message) != 0 { 2447 errorMessage = message 2448 } 2449 2450 switch { 2451 case strings.EqualFold("ClientException", errorCode): 2452 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2453 2454 case strings.EqualFold("ServerException", errorCode): 2455 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2456 2457 default: 2458 genericError := &smithy.GenericAPIError{ 2459 Code: errorCode, 2460 Message: errorMessage, 2461 } 2462 return genericError 2463 2464 } 2465} 2466 2467type awsAwsjson11_deserializeOpExecuteCommand struct { 2468} 2469 2470func (*awsAwsjson11_deserializeOpExecuteCommand) ID() string { 2471 return "OperationDeserializer" 2472} 2473 2474func (m *awsAwsjson11_deserializeOpExecuteCommand) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2475 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2476) { 2477 out, metadata, err = next.HandleDeserialize(ctx, in) 2478 if err != nil { 2479 return out, metadata, err 2480 } 2481 2482 response, ok := out.RawResponse.(*smithyhttp.Response) 2483 if !ok { 2484 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2485 } 2486 2487 if response.StatusCode < 200 || response.StatusCode >= 300 { 2488 return out, metadata, awsAwsjson11_deserializeOpErrorExecuteCommand(response, &metadata) 2489 } 2490 output := &ExecuteCommandOutput{} 2491 out.Result = output 2492 2493 var buff [1024]byte 2494 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2495 2496 body := io.TeeReader(response.Body, ringBuffer) 2497 decoder := json.NewDecoder(body) 2498 decoder.UseNumber() 2499 var shape interface{} 2500 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2501 var snapshot bytes.Buffer 2502 io.Copy(&snapshot, ringBuffer) 2503 err = &smithy.DeserializationError{ 2504 Err: fmt.Errorf("failed to decode response body, %w", err), 2505 Snapshot: snapshot.Bytes(), 2506 } 2507 return out, metadata, err 2508 } 2509 2510 err = awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(&output, shape) 2511 if err != nil { 2512 var snapshot bytes.Buffer 2513 io.Copy(&snapshot, ringBuffer) 2514 err = &smithy.DeserializationError{ 2515 Err: fmt.Errorf("failed to decode response body, %w", err), 2516 Snapshot: snapshot.Bytes(), 2517 } 2518 return out, metadata, err 2519 } 2520 2521 return out, metadata, err 2522} 2523 2524func awsAwsjson11_deserializeOpErrorExecuteCommand(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2525 var errorBuffer bytes.Buffer 2526 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2527 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2528 } 2529 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2530 2531 errorCode := "UnknownError" 2532 errorMessage := errorCode 2533 2534 code := response.Header.Get("X-Amzn-ErrorType") 2535 if len(code) != 0 { 2536 errorCode = restjson.SanitizeErrorCode(code) 2537 } 2538 2539 var buff [1024]byte 2540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2541 2542 body := io.TeeReader(errorBody, ringBuffer) 2543 decoder := json.NewDecoder(body) 2544 decoder.UseNumber() 2545 code, message, err := restjson.GetErrorInfo(decoder) 2546 if err != nil { 2547 var snapshot bytes.Buffer 2548 io.Copy(&snapshot, ringBuffer) 2549 err = &smithy.DeserializationError{ 2550 Err: fmt.Errorf("failed to decode response body, %w", err), 2551 Snapshot: snapshot.Bytes(), 2552 } 2553 return err 2554 } 2555 2556 errorBody.Seek(0, io.SeekStart) 2557 if len(code) != 0 { 2558 errorCode = restjson.SanitizeErrorCode(code) 2559 } 2560 if len(message) != 0 { 2561 errorMessage = message 2562 } 2563 2564 switch { 2565 case strings.EqualFold("AccessDeniedException", errorCode): 2566 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2567 2568 case strings.EqualFold("ClientException", errorCode): 2569 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2570 2571 case strings.EqualFold("ClusterNotFoundException", errorCode): 2572 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 2573 2574 case strings.EqualFold("InvalidParameterException", errorCode): 2575 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2576 2577 case strings.EqualFold("ServerException", errorCode): 2578 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2579 2580 case strings.EqualFold("TargetNotConnectedException", errorCode): 2581 return awsAwsjson11_deserializeErrorTargetNotConnectedException(response, errorBody) 2582 2583 default: 2584 genericError := &smithy.GenericAPIError{ 2585 Code: errorCode, 2586 Message: errorMessage, 2587 } 2588 return genericError 2589 2590 } 2591} 2592 2593type awsAwsjson11_deserializeOpListAccountSettings struct { 2594} 2595 2596func (*awsAwsjson11_deserializeOpListAccountSettings) ID() string { 2597 return "OperationDeserializer" 2598} 2599 2600func (m *awsAwsjson11_deserializeOpListAccountSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2601 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2602) { 2603 out, metadata, err = next.HandleDeserialize(ctx, in) 2604 if err != nil { 2605 return out, metadata, err 2606 } 2607 2608 response, ok := out.RawResponse.(*smithyhttp.Response) 2609 if !ok { 2610 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2611 } 2612 2613 if response.StatusCode < 200 || response.StatusCode >= 300 { 2614 return out, metadata, awsAwsjson11_deserializeOpErrorListAccountSettings(response, &metadata) 2615 } 2616 output := &ListAccountSettingsOutput{} 2617 out.Result = output 2618 2619 var buff [1024]byte 2620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2621 2622 body := io.TeeReader(response.Body, ringBuffer) 2623 decoder := json.NewDecoder(body) 2624 decoder.UseNumber() 2625 var shape interface{} 2626 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2627 var snapshot bytes.Buffer 2628 io.Copy(&snapshot, ringBuffer) 2629 err = &smithy.DeserializationError{ 2630 Err: fmt.Errorf("failed to decode response body, %w", err), 2631 Snapshot: snapshot.Bytes(), 2632 } 2633 return out, metadata, err 2634 } 2635 2636 err = awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(&output, shape) 2637 if err != nil { 2638 var snapshot bytes.Buffer 2639 io.Copy(&snapshot, ringBuffer) 2640 err = &smithy.DeserializationError{ 2641 Err: fmt.Errorf("failed to decode response body, %w", err), 2642 Snapshot: snapshot.Bytes(), 2643 } 2644 return out, metadata, err 2645 } 2646 2647 return out, metadata, err 2648} 2649 2650func awsAwsjson11_deserializeOpErrorListAccountSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2651 var errorBuffer bytes.Buffer 2652 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2653 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2654 } 2655 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2656 2657 errorCode := "UnknownError" 2658 errorMessage := errorCode 2659 2660 code := response.Header.Get("X-Amzn-ErrorType") 2661 if len(code) != 0 { 2662 errorCode = restjson.SanitizeErrorCode(code) 2663 } 2664 2665 var buff [1024]byte 2666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2667 2668 body := io.TeeReader(errorBody, ringBuffer) 2669 decoder := json.NewDecoder(body) 2670 decoder.UseNumber() 2671 code, message, err := restjson.GetErrorInfo(decoder) 2672 if err != nil { 2673 var snapshot bytes.Buffer 2674 io.Copy(&snapshot, ringBuffer) 2675 err = &smithy.DeserializationError{ 2676 Err: fmt.Errorf("failed to decode response body, %w", err), 2677 Snapshot: snapshot.Bytes(), 2678 } 2679 return err 2680 } 2681 2682 errorBody.Seek(0, io.SeekStart) 2683 if len(code) != 0 { 2684 errorCode = restjson.SanitizeErrorCode(code) 2685 } 2686 if len(message) != 0 { 2687 errorMessage = message 2688 } 2689 2690 switch { 2691 case strings.EqualFold("ClientException", errorCode): 2692 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2693 2694 case strings.EqualFold("InvalidParameterException", errorCode): 2695 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2696 2697 case strings.EqualFold("ServerException", errorCode): 2698 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2699 2700 default: 2701 genericError := &smithy.GenericAPIError{ 2702 Code: errorCode, 2703 Message: errorMessage, 2704 } 2705 return genericError 2706 2707 } 2708} 2709 2710type awsAwsjson11_deserializeOpListAttributes struct { 2711} 2712 2713func (*awsAwsjson11_deserializeOpListAttributes) ID() string { 2714 return "OperationDeserializer" 2715} 2716 2717func (m *awsAwsjson11_deserializeOpListAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2718 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2719) { 2720 out, metadata, err = next.HandleDeserialize(ctx, in) 2721 if err != nil { 2722 return out, metadata, err 2723 } 2724 2725 response, ok := out.RawResponse.(*smithyhttp.Response) 2726 if !ok { 2727 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2728 } 2729 2730 if response.StatusCode < 200 || response.StatusCode >= 300 { 2731 return out, metadata, awsAwsjson11_deserializeOpErrorListAttributes(response, &metadata) 2732 } 2733 output := &ListAttributesOutput{} 2734 out.Result = output 2735 2736 var buff [1024]byte 2737 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2738 2739 body := io.TeeReader(response.Body, ringBuffer) 2740 decoder := json.NewDecoder(body) 2741 decoder.UseNumber() 2742 var shape interface{} 2743 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2744 var snapshot bytes.Buffer 2745 io.Copy(&snapshot, ringBuffer) 2746 err = &smithy.DeserializationError{ 2747 Err: fmt.Errorf("failed to decode response body, %w", err), 2748 Snapshot: snapshot.Bytes(), 2749 } 2750 return out, metadata, err 2751 } 2752 2753 err = awsAwsjson11_deserializeOpDocumentListAttributesOutput(&output, shape) 2754 if err != nil { 2755 var snapshot bytes.Buffer 2756 io.Copy(&snapshot, ringBuffer) 2757 err = &smithy.DeserializationError{ 2758 Err: fmt.Errorf("failed to decode response body, %w", err), 2759 Snapshot: snapshot.Bytes(), 2760 } 2761 return out, metadata, err 2762 } 2763 2764 return out, metadata, err 2765} 2766 2767func awsAwsjson11_deserializeOpErrorListAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2768 var errorBuffer bytes.Buffer 2769 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2770 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2771 } 2772 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2773 2774 errorCode := "UnknownError" 2775 errorMessage := errorCode 2776 2777 code := response.Header.Get("X-Amzn-ErrorType") 2778 if len(code) != 0 { 2779 errorCode = restjson.SanitizeErrorCode(code) 2780 } 2781 2782 var buff [1024]byte 2783 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2784 2785 body := io.TeeReader(errorBody, ringBuffer) 2786 decoder := json.NewDecoder(body) 2787 decoder.UseNumber() 2788 code, message, err := restjson.GetErrorInfo(decoder) 2789 if err != nil { 2790 var snapshot bytes.Buffer 2791 io.Copy(&snapshot, ringBuffer) 2792 err = &smithy.DeserializationError{ 2793 Err: fmt.Errorf("failed to decode response body, %w", err), 2794 Snapshot: snapshot.Bytes(), 2795 } 2796 return err 2797 } 2798 2799 errorBody.Seek(0, io.SeekStart) 2800 if len(code) != 0 { 2801 errorCode = restjson.SanitizeErrorCode(code) 2802 } 2803 if len(message) != 0 { 2804 errorMessage = message 2805 } 2806 2807 switch { 2808 case strings.EqualFold("ClusterNotFoundException", errorCode): 2809 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 2810 2811 case strings.EqualFold("InvalidParameterException", errorCode): 2812 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2813 2814 default: 2815 genericError := &smithy.GenericAPIError{ 2816 Code: errorCode, 2817 Message: errorMessage, 2818 } 2819 return genericError 2820 2821 } 2822} 2823 2824type awsAwsjson11_deserializeOpListClusters struct { 2825} 2826 2827func (*awsAwsjson11_deserializeOpListClusters) ID() string { 2828 return "OperationDeserializer" 2829} 2830 2831func (m *awsAwsjson11_deserializeOpListClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2832 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2833) { 2834 out, metadata, err = next.HandleDeserialize(ctx, in) 2835 if err != nil { 2836 return out, metadata, err 2837 } 2838 2839 response, ok := out.RawResponse.(*smithyhttp.Response) 2840 if !ok { 2841 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2842 } 2843 2844 if response.StatusCode < 200 || response.StatusCode >= 300 { 2845 return out, metadata, awsAwsjson11_deserializeOpErrorListClusters(response, &metadata) 2846 } 2847 output := &ListClustersOutput{} 2848 out.Result = output 2849 2850 var buff [1024]byte 2851 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2852 2853 body := io.TeeReader(response.Body, ringBuffer) 2854 decoder := json.NewDecoder(body) 2855 decoder.UseNumber() 2856 var shape interface{} 2857 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2858 var snapshot bytes.Buffer 2859 io.Copy(&snapshot, ringBuffer) 2860 err = &smithy.DeserializationError{ 2861 Err: fmt.Errorf("failed to decode response body, %w", err), 2862 Snapshot: snapshot.Bytes(), 2863 } 2864 return out, metadata, err 2865 } 2866 2867 err = awsAwsjson11_deserializeOpDocumentListClustersOutput(&output, shape) 2868 if err != nil { 2869 var snapshot bytes.Buffer 2870 io.Copy(&snapshot, ringBuffer) 2871 err = &smithy.DeserializationError{ 2872 Err: fmt.Errorf("failed to decode response body, %w", err), 2873 Snapshot: snapshot.Bytes(), 2874 } 2875 return out, metadata, err 2876 } 2877 2878 return out, metadata, err 2879} 2880 2881func awsAwsjson11_deserializeOpErrorListClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2882 var errorBuffer bytes.Buffer 2883 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2884 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2885 } 2886 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2887 2888 errorCode := "UnknownError" 2889 errorMessage := errorCode 2890 2891 code := response.Header.Get("X-Amzn-ErrorType") 2892 if len(code) != 0 { 2893 errorCode = restjson.SanitizeErrorCode(code) 2894 } 2895 2896 var buff [1024]byte 2897 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2898 2899 body := io.TeeReader(errorBody, ringBuffer) 2900 decoder := json.NewDecoder(body) 2901 decoder.UseNumber() 2902 code, message, err := restjson.GetErrorInfo(decoder) 2903 if err != nil { 2904 var snapshot bytes.Buffer 2905 io.Copy(&snapshot, ringBuffer) 2906 err = &smithy.DeserializationError{ 2907 Err: fmt.Errorf("failed to decode response body, %w", err), 2908 Snapshot: snapshot.Bytes(), 2909 } 2910 return err 2911 } 2912 2913 errorBody.Seek(0, io.SeekStart) 2914 if len(code) != 0 { 2915 errorCode = restjson.SanitizeErrorCode(code) 2916 } 2917 if len(message) != 0 { 2918 errorMessage = message 2919 } 2920 2921 switch { 2922 case strings.EqualFold("ClientException", errorCode): 2923 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 2924 2925 case strings.EqualFold("InvalidParameterException", errorCode): 2926 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2927 2928 case strings.EqualFold("ServerException", errorCode): 2929 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 2930 2931 default: 2932 genericError := &smithy.GenericAPIError{ 2933 Code: errorCode, 2934 Message: errorMessage, 2935 } 2936 return genericError 2937 2938 } 2939} 2940 2941type awsAwsjson11_deserializeOpListContainerInstances struct { 2942} 2943 2944func (*awsAwsjson11_deserializeOpListContainerInstances) ID() string { 2945 return "OperationDeserializer" 2946} 2947 2948func (m *awsAwsjson11_deserializeOpListContainerInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2949 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2950) { 2951 out, metadata, err = next.HandleDeserialize(ctx, in) 2952 if err != nil { 2953 return out, metadata, err 2954 } 2955 2956 response, ok := out.RawResponse.(*smithyhttp.Response) 2957 if !ok { 2958 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2959 } 2960 2961 if response.StatusCode < 200 || response.StatusCode >= 300 { 2962 return out, metadata, awsAwsjson11_deserializeOpErrorListContainerInstances(response, &metadata) 2963 } 2964 output := &ListContainerInstancesOutput{} 2965 out.Result = output 2966 2967 var buff [1024]byte 2968 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2969 2970 body := io.TeeReader(response.Body, ringBuffer) 2971 decoder := json.NewDecoder(body) 2972 decoder.UseNumber() 2973 var shape interface{} 2974 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2975 var snapshot bytes.Buffer 2976 io.Copy(&snapshot, ringBuffer) 2977 err = &smithy.DeserializationError{ 2978 Err: fmt.Errorf("failed to decode response body, %w", err), 2979 Snapshot: snapshot.Bytes(), 2980 } 2981 return out, metadata, err 2982 } 2983 2984 err = awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(&output, shape) 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 out, metadata, err 2993 } 2994 2995 return out, metadata, err 2996} 2997 2998func awsAwsjson11_deserializeOpErrorListContainerInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2999 var errorBuffer bytes.Buffer 3000 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3001 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3002 } 3003 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3004 3005 errorCode := "UnknownError" 3006 errorMessage := errorCode 3007 3008 code := response.Header.Get("X-Amzn-ErrorType") 3009 if len(code) != 0 { 3010 errorCode = restjson.SanitizeErrorCode(code) 3011 } 3012 3013 var buff [1024]byte 3014 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3015 3016 body := io.TeeReader(errorBody, ringBuffer) 3017 decoder := json.NewDecoder(body) 3018 decoder.UseNumber() 3019 code, message, err := restjson.GetErrorInfo(decoder) 3020 if err != nil { 3021 var snapshot bytes.Buffer 3022 io.Copy(&snapshot, ringBuffer) 3023 err = &smithy.DeserializationError{ 3024 Err: fmt.Errorf("failed to decode response body, %w", err), 3025 Snapshot: snapshot.Bytes(), 3026 } 3027 return err 3028 } 3029 3030 errorBody.Seek(0, io.SeekStart) 3031 if len(code) != 0 { 3032 errorCode = restjson.SanitizeErrorCode(code) 3033 } 3034 if len(message) != 0 { 3035 errorMessage = message 3036 } 3037 3038 switch { 3039 case strings.EqualFold("ClientException", errorCode): 3040 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3041 3042 case strings.EqualFold("ClusterNotFoundException", errorCode): 3043 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 3044 3045 case strings.EqualFold("InvalidParameterException", errorCode): 3046 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3047 3048 case strings.EqualFold("ServerException", errorCode): 3049 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3050 3051 default: 3052 genericError := &smithy.GenericAPIError{ 3053 Code: errorCode, 3054 Message: errorMessage, 3055 } 3056 return genericError 3057 3058 } 3059} 3060 3061type awsAwsjson11_deserializeOpListServices struct { 3062} 3063 3064func (*awsAwsjson11_deserializeOpListServices) ID() string { 3065 return "OperationDeserializer" 3066} 3067 3068func (m *awsAwsjson11_deserializeOpListServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3069 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3070) { 3071 out, metadata, err = next.HandleDeserialize(ctx, in) 3072 if err != nil { 3073 return out, metadata, err 3074 } 3075 3076 response, ok := out.RawResponse.(*smithyhttp.Response) 3077 if !ok { 3078 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3079 } 3080 3081 if response.StatusCode < 200 || response.StatusCode >= 300 { 3082 return out, metadata, awsAwsjson11_deserializeOpErrorListServices(response, &metadata) 3083 } 3084 output := &ListServicesOutput{} 3085 out.Result = output 3086 3087 var buff [1024]byte 3088 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3089 3090 body := io.TeeReader(response.Body, ringBuffer) 3091 decoder := json.NewDecoder(body) 3092 decoder.UseNumber() 3093 var shape interface{} 3094 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3095 var snapshot bytes.Buffer 3096 io.Copy(&snapshot, ringBuffer) 3097 err = &smithy.DeserializationError{ 3098 Err: fmt.Errorf("failed to decode response body, %w", err), 3099 Snapshot: snapshot.Bytes(), 3100 } 3101 return out, metadata, err 3102 } 3103 3104 err = awsAwsjson11_deserializeOpDocumentListServicesOutput(&output, shape) 3105 if err != nil { 3106 var snapshot bytes.Buffer 3107 io.Copy(&snapshot, ringBuffer) 3108 err = &smithy.DeserializationError{ 3109 Err: fmt.Errorf("failed to decode response body, %w", err), 3110 Snapshot: snapshot.Bytes(), 3111 } 3112 return out, metadata, err 3113 } 3114 3115 return out, metadata, err 3116} 3117 3118func awsAwsjson11_deserializeOpErrorListServices(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3119 var errorBuffer bytes.Buffer 3120 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3121 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3122 } 3123 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3124 3125 errorCode := "UnknownError" 3126 errorMessage := errorCode 3127 3128 code := response.Header.Get("X-Amzn-ErrorType") 3129 if len(code) != 0 { 3130 errorCode = restjson.SanitizeErrorCode(code) 3131 } 3132 3133 var buff [1024]byte 3134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3135 3136 body := io.TeeReader(errorBody, ringBuffer) 3137 decoder := json.NewDecoder(body) 3138 decoder.UseNumber() 3139 code, message, err := restjson.GetErrorInfo(decoder) 3140 if err != nil { 3141 var snapshot bytes.Buffer 3142 io.Copy(&snapshot, ringBuffer) 3143 err = &smithy.DeserializationError{ 3144 Err: fmt.Errorf("failed to decode response body, %w", err), 3145 Snapshot: snapshot.Bytes(), 3146 } 3147 return err 3148 } 3149 3150 errorBody.Seek(0, io.SeekStart) 3151 if len(code) != 0 { 3152 errorCode = restjson.SanitizeErrorCode(code) 3153 } 3154 if len(message) != 0 { 3155 errorMessage = message 3156 } 3157 3158 switch { 3159 case strings.EqualFold("ClientException", errorCode): 3160 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3161 3162 case strings.EqualFold("ClusterNotFoundException", errorCode): 3163 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 3164 3165 case strings.EqualFold("InvalidParameterException", errorCode): 3166 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3167 3168 case strings.EqualFold("ServerException", errorCode): 3169 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3170 3171 default: 3172 genericError := &smithy.GenericAPIError{ 3173 Code: errorCode, 3174 Message: errorMessage, 3175 } 3176 return genericError 3177 3178 } 3179} 3180 3181type awsAwsjson11_deserializeOpListTagsForResource struct { 3182} 3183 3184func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 3185 return "OperationDeserializer" 3186} 3187 3188func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3189 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3190) { 3191 out, metadata, err = next.HandleDeserialize(ctx, in) 3192 if err != nil { 3193 return out, metadata, err 3194 } 3195 3196 response, ok := out.RawResponse.(*smithyhttp.Response) 3197 if !ok { 3198 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3199 } 3200 3201 if response.StatusCode < 200 || response.StatusCode >= 300 { 3202 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 3203 } 3204 output := &ListTagsForResourceOutput{} 3205 out.Result = output 3206 3207 var buff [1024]byte 3208 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3209 3210 body := io.TeeReader(response.Body, ringBuffer) 3211 decoder := json.NewDecoder(body) 3212 decoder.UseNumber() 3213 var shape interface{} 3214 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3215 var snapshot bytes.Buffer 3216 io.Copy(&snapshot, ringBuffer) 3217 err = &smithy.DeserializationError{ 3218 Err: fmt.Errorf("failed to decode response body, %w", err), 3219 Snapshot: snapshot.Bytes(), 3220 } 3221 return out, metadata, err 3222 } 3223 3224 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 3225 if err != nil { 3226 var snapshot bytes.Buffer 3227 io.Copy(&snapshot, ringBuffer) 3228 err = &smithy.DeserializationError{ 3229 Err: fmt.Errorf("failed to decode response body, %w", err), 3230 Snapshot: snapshot.Bytes(), 3231 } 3232 return out, metadata, err 3233 } 3234 3235 return out, metadata, err 3236} 3237 3238func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3239 var errorBuffer bytes.Buffer 3240 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3241 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3242 } 3243 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3244 3245 errorCode := "UnknownError" 3246 errorMessage := errorCode 3247 3248 code := response.Header.Get("X-Amzn-ErrorType") 3249 if len(code) != 0 { 3250 errorCode = restjson.SanitizeErrorCode(code) 3251 } 3252 3253 var buff [1024]byte 3254 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3255 3256 body := io.TeeReader(errorBody, ringBuffer) 3257 decoder := json.NewDecoder(body) 3258 decoder.UseNumber() 3259 code, message, err := restjson.GetErrorInfo(decoder) 3260 if err != nil { 3261 var snapshot bytes.Buffer 3262 io.Copy(&snapshot, ringBuffer) 3263 err = &smithy.DeserializationError{ 3264 Err: fmt.Errorf("failed to decode response body, %w", err), 3265 Snapshot: snapshot.Bytes(), 3266 } 3267 return err 3268 } 3269 3270 errorBody.Seek(0, io.SeekStart) 3271 if len(code) != 0 { 3272 errorCode = restjson.SanitizeErrorCode(code) 3273 } 3274 if len(message) != 0 { 3275 errorMessage = message 3276 } 3277 3278 switch { 3279 case strings.EqualFold("ClientException", errorCode): 3280 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3281 3282 case strings.EqualFold("ClusterNotFoundException", errorCode): 3283 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 3284 3285 case strings.EqualFold("InvalidParameterException", errorCode): 3286 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3287 3288 case strings.EqualFold("ServerException", errorCode): 3289 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3290 3291 default: 3292 genericError := &smithy.GenericAPIError{ 3293 Code: errorCode, 3294 Message: errorMessage, 3295 } 3296 return genericError 3297 3298 } 3299} 3300 3301type awsAwsjson11_deserializeOpListTaskDefinitionFamilies struct { 3302} 3303 3304func (*awsAwsjson11_deserializeOpListTaskDefinitionFamilies) ID() string { 3305 return "OperationDeserializer" 3306} 3307 3308func (m *awsAwsjson11_deserializeOpListTaskDefinitionFamilies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3309 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3310) { 3311 out, metadata, err = next.HandleDeserialize(ctx, in) 3312 if err != nil { 3313 return out, metadata, err 3314 } 3315 3316 response, ok := out.RawResponse.(*smithyhttp.Response) 3317 if !ok { 3318 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3319 } 3320 3321 if response.StatusCode < 200 || response.StatusCode >= 300 { 3322 return out, metadata, awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(response, &metadata) 3323 } 3324 output := &ListTaskDefinitionFamiliesOutput{} 3325 out.Result = output 3326 3327 var buff [1024]byte 3328 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3329 3330 body := io.TeeReader(response.Body, ringBuffer) 3331 decoder := json.NewDecoder(body) 3332 decoder.UseNumber() 3333 var shape interface{} 3334 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3335 var snapshot bytes.Buffer 3336 io.Copy(&snapshot, ringBuffer) 3337 err = &smithy.DeserializationError{ 3338 Err: fmt.Errorf("failed to decode response body, %w", err), 3339 Snapshot: snapshot.Bytes(), 3340 } 3341 return out, metadata, err 3342 } 3343 3344 err = awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(&output, shape) 3345 if err != nil { 3346 var snapshot bytes.Buffer 3347 io.Copy(&snapshot, ringBuffer) 3348 err = &smithy.DeserializationError{ 3349 Err: fmt.Errorf("failed to decode response body, %w", err), 3350 Snapshot: snapshot.Bytes(), 3351 } 3352 return out, metadata, err 3353 } 3354 3355 return out, metadata, err 3356} 3357 3358func awsAwsjson11_deserializeOpErrorListTaskDefinitionFamilies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3359 var errorBuffer bytes.Buffer 3360 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3361 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3362 } 3363 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3364 3365 errorCode := "UnknownError" 3366 errorMessage := errorCode 3367 3368 code := response.Header.Get("X-Amzn-ErrorType") 3369 if len(code) != 0 { 3370 errorCode = restjson.SanitizeErrorCode(code) 3371 } 3372 3373 var buff [1024]byte 3374 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3375 3376 body := io.TeeReader(errorBody, ringBuffer) 3377 decoder := json.NewDecoder(body) 3378 decoder.UseNumber() 3379 code, message, err := restjson.GetErrorInfo(decoder) 3380 if err != nil { 3381 var snapshot bytes.Buffer 3382 io.Copy(&snapshot, ringBuffer) 3383 err = &smithy.DeserializationError{ 3384 Err: fmt.Errorf("failed to decode response body, %w", err), 3385 Snapshot: snapshot.Bytes(), 3386 } 3387 return err 3388 } 3389 3390 errorBody.Seek(0, io.SeekStart) 3391 if len(code) != 0 { 3392 errorCode = restjson.SanitizeErrorCode(code) 3393 } 3394 if len(message) != 0 { 3395 errorMessage = message 3396 } 3397 3398 switch { 3399 case strings.EqualFold("ClientException", errorCode): 3400 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3401 3402 case strings.EqualFold("InvalidParameterException", errorCode): 3403 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3404 3405 case strings.EqualFold("ServerException", errorCode): 3406 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3407 3408 default: 3409 genericError := &smithy.GenericAPIError{ 3410 Code: errorCode, 3411 Message: errorMessage, 3412 } 3413 return genericError 3414 3415 } 3416} 3417 3418type awsAwsjson11_deserializeOpListTaskDefinitions struct { 3419} 3420 3421func (*awsAwsjson11_deserializeOpListTaskDefinitions) ID() string { 3422 return "OperationDeserializer" 3423} 3424 3425func (m *awsAwsjson11_deserializeOpListTaskDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3426 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3427) { 3428 out, metadata, err = next.HandleDeserialize(ctx, in) 3429 if err != nil { 3430 return out, metadata, err 3431 } 3432 3433 response, ok := out.RawResponse.(*smithyhttp.Response) 3434 if !ok { 3435 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3436 } 3437 3438 if response.StatusCode < 200 || response.StatusCode >= 300 { 3439 return out, metadata, awsAwsjson11_deserializeOpErrorListTaskDefinitions(response, &metadata) 3440 } 3441 output := &ListTaskDefinitionsOutput{} 3442 out.Result = output 3443 3444 var buff [1024]byte 3445 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3446 3447 body := io.TeeReader(response.Body, ringBuffer) 3448 decoder := json.NewDecoder(body) 3449 decoder.UseNumber() 3450 var shape interface{} 3451 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3452 var snapshot bytes.Buffer 3453 io.Copy(&snapshot, ringBuffer) 3454 err = &smithy.DeserializationError{ 3455 Err: fmt.Errorf("failed to decode response body, %w", err), 3456 Snapshot: snapshot.Bytes(), 3457 } 3458 return out, metadata, err 3459 } 3460 3461 err = awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(&output, shape) 3462 if err != nil { 3463 var snapshot bytes.Buffer 3464 io.Copy(&snapshot, ringBuffer) 3465 err = &smithy.DeserializationError{ 3466 Err: fmt.Errorf("failed to decode response body, %w", err), 3467 Snapshot: snapshot.Bytes(), 3468 } 3469 return out, metadata, err 3470 } 3471 3472 return out, metadata, err 3473} 3474 3475func awsAwsjson11_deserializeOpErrorListTaskDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3476 var errorBuffer bytes.Buffer 3477 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3478 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3479 } 3480 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3481 3482 errorCode := "UnknownError" 3483 errorMessage := errorCode 3484 3485 code := response.Header.Get("X-Amzn-ErrorType") 3486 if len(code) != 0 { 3487 errorCode = restjson.SanitizeErrorCode(code) 3488 } 3489 3490 var buff [1024]byte 3491 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3492 3493 body := io.TeeReader(errorBody, ringBuffer) 3494 decoder := json.NewDecoder(body) 3495 decoder.UseNumber() 3496 code, message, err := restjson.GetErrorInfo(decoder) 3497 if err != nil { 3498 var snapshot bytes.Buffer 3499 io.Copy(&snapshot, ringBuffer) 3500 err = &smithy.DeserializationError{ 3501 Err: fmt.Errorf("failed to decode response body, %w", err), 3502 Snapshot: snapshot.Bytes(), 3503 } 3504 return err 3505 } 3506 3507 errorBody.Seek(0, io.SeekStart) 3508 if len(code) != 0 { 3509 errorCode = restjson.SanitizeErrorCode(code) 3510 } 3511 if len(message) != 0 { 3512 errorMessage = message 3513 } 3514 3515 switch { 3516 case strings.EqualFold("ClientException", errorCode): 3517 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3518 3519 case strings.EqualFold("InvalidParameterException", errorCode): 3520 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3521 3522 case strings.EqualFold("ServerException", errorCode): 3523 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3524 3525 default: 3526 genericError := &smithy.GenericAPIError{ 3527 Code: errorCode, 3528 Message: errorMessage, 3529 } 3530 return genericError 3531 3532 } 3533} 3534 3535type awsAwsjson11_deserializeOpListTasks struct { 3536} 3537 3538func (*awsAwsjson11_deserializeOpListTasks) ID() string { 3539 return "OperationDeserializer" 3540} 3541 3542func (m *awsAwsjson11_deserializeOpListTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3543 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3544) { 3545 out, metadata, err = next.HandleDeserialize(ctx, in) 3546 if err != nil { 3547 return out, metadata, err 3548 } 3549 3550 response, ok := out.RawResponse.(*smithyhttp.Response) 3551 if !ok { 3552 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3553 } 3554 3555 if response.StatusCode < 200 || response.StatusCode >= 300 { 3556 return out, metadata, awsAwsjson11_deserializeOpErrorListTasks(response, &metadata) 3557 } 3558 output := &ListTasksOutput{} 3559 out.Result = output 3560 3561 var buff [1024]byte 3562 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3563 3564 body := io.TeeReader(response.Body, ringBuffer) 3565 decoder := json.NewDecoder(body) 3566 decoder.UseNumber() 3567 var shape interface{} 3568 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3569 var snapshot bytes.Buffer 3570 io.Copy(&snapshot, ringBuffer) 3571 err = &smithy.DeserializationError{ 3572 Err: fmt.Errorf("failed to decode response body, %w", err), 3573 Snapshot: snapshot.Bytes(), 3574 } 3575 return out, metadata, err 3576 } 3577 3578 err = awsAwsjson11_deserializeOpDocumentListTasksOutput(&output, shape) 3579 if err != nil { 3580 var snapshot bytes.Buffer 3581 io.Copy(&snapshot, ringBuffer) 3582 err = &smithy.DeserializationError{ 3583 Err: fmt.Errorf("failed to decode response body, %w", err), 3584 Snapshot: snapshot.Bytes(), 3585 } 3586 return out, metadata, err 3587 } 3588 3589 return out, metadata, err 3590} 3591 3592func awsAwsjson11_deserializeOpErrorListTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3593 var errorBuffer bytes.Buffer 3594 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3595 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3596 } 3597 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3598 3599 errorCode := "UnknownError" 3600 errorMessage := errorCode 3601 3602 code := response.Header.Get("X-Amzn-ErrorType") 3603 if len(code) != 0 { 3604 errorCode = restjson.SanitizeErrorCode(code) 3605 } 3606 3607 var buff [1024]byte 3608 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3609 3610 body := io.TeeReader(errorBody, ringBuffer) 3611 decoder := json.NewDecoder(body) 3612 decoder.UseNumber() 3613 code, message, err := restjson.GetErrorInfo(decoder) 3614 if err != nil { 3615 var snapshot bytes.Buffer 3616 io.Copy(&snapshot, ringBuffer) 3617 err = &smithy.DeserializationError{ 3618 Err: fmt.Errorf("failed to decode response body, %w", err), 3619 Snapshot: snapshot.Bytes(), 3620 } 3621 return err 3622 } 3623 3624 errorBody.Seek(0, io.SeekStart) 3625 if len(code) != 0 { 3626 errorCode = restjson.SanitizeErrorCode(code) 3627 } 3628 if len(message) != 0 { 3629 errorMessage = message 3630 } 3631 3632 switch { 3633 case strings.EqualFold("ClientException", errorCode): 3634 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3635 3636 case strings.EqualFold("ClusterNotFoundException", errorCode): 3637 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 3638 3639 case strings.EqualFold("InvalidParameterException", errorCode): 3640 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3641 3642 case strings.EqualFold("ServerException", errorCode): 3643 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3644 3645 case strings.EqualFold("ServiceNotFoundException", errorCode): 3646 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 3647 3648 default: 3649 genericError := &smithy.GenericAPIError{ 3650 Code: errorCode, 3651 Message: errorMessage, 3652 } 3653 return genericError 3654 3655 } 3656} 3657 3658type awsAwsjson11_deserializeOpPutAccountSetting struct { 3659} 3660 3661func (*awsAwsjson11_deserializeOpPutAccountSetting) ID() string { 3662 return "OperationDeserializer" 3663} 3664 3665func (m *awsAwsjson11_deserializeOpPutAccountSetting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3666 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3667) { 3668 out, metadata, err = next.HandleDeserialize(ctx, in) 3669 if err != nil { 3670 return out, metadata, err 3671 } 3672 3673 response, ok := out.RawResponse.(*smithyhttp.Response) 3674 if !ok { 3675 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3676 } 3677 3678 if response.StatusCode < 200 || response.StatusCode >= 300 { 3679 return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountSetting(response, &metadata) 3680 } 3681 output := &PutAccountSettingOutput{} 3682 out.Result = output 3683 3684 var buff [1024]byte 3685 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3686 3687 body := io.TeeReader(response.Body, ringBuffer) 3688 decoder := json.NewDecoder(body) 3689 decoder.UseNumber() 3690 var shape interface{} 3691 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3692 var snapshot bytes.Buffer 3693 io.Copy(&snapshot, ringBuffer) 3694 err = &smithy.DeserializationError{ 3695 Err: fmt.Errorf("failed to decode response body, %w", err), 3696 Snapshot: snapshot.Bytes(), 3697 } 3698 return out, metadata, err 3699 } 3700 3701 err = awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(&output, shape) 3702 if err != nil { 3703 var snapshot bytes.Buffer 3704 io.Copy(&snapshot, ringBuffer) 3705 err = &smithy.DeserializationError{ 3706 Err: fmt.Errorf("failed to decode response body, %w", err), 3707 Snapshot: snapshot.Bytes(), 3708 } 3709 return out, metadata, err 3710 } 3711 3712 return out, metadata, err 3713} 3714 3715func awsAwsjson11_deserializeOpErrorPutAccountSetting(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3716 var errorBuffer bytes.Buffer 3717 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3718 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3719 } 3720 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3721 3722 errorCode := "UnknownError" 3723 errorMessage := errorCode 3724 3725 code := response.Header.Get("X-Amzn-ErrorType") 3726 if len(code) != 0 { 3727 errorCode = restjson.SanitizeErrorCode(code) 3728 } 3729 3730 var buff [1024]byte 3731 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3732 3733 body := io.TeeReader(errorBody, ringBuffer) 3734 decoder := json.NewDecoder(body) 3735 decoder.UseNumber() 3736 code, message, err := restjson.GetErrorInfo(decoder) 3737 if err != nil { 3738 var snapshot bytes.Buffer 3739 io.Copy(&snapshot, ringBuffer) 3740 err = &smithy.DeserializationError{ 3741 Err: fmt.Errorf("failed to decode response body, %w", err), 3742 Snapshot: snapshot.Bytes(), 3743 } 3744 return err 3745 } 3746 3747 errorBody.Seek(0, io.SeekStart) 3748 if len(code) != 0 { 3749 errorCode = restjson.SanitizeErrorCode(code) 3750 } 3751 if len(message) != 0 { 3752 errorMessage = message 3753 } 3754 3755 switch { 3756 case strings.EqualFold("ClientException", errorCode): 3757 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3758 3759 case strings.EqualFold("InvalidParameterException", errorCode): 3760 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3761 3762 case strings.EqualFold("ServerException", errorCode): 3763 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3764 3765 default: 3766 genericError := &smithy.GenericAPIError{ 3767 Code: errorCode, 3768 Message: errorMessage, 3769 } 3770 return genericError 3771 3772 } 3773} 3774 3775type awsAwsjson11_deserializeOpPutAccountSettingDefault struct { 3776} 3777 3778func (*awsAwsjson11_deserializeOpPutAccountSettingDefault) ID() string { 3779 return "OperationDeserializer" 3780} 3781 3782func (m *awsAwsjson11_deserializeOpPutAccountSettingDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3783 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3784) { 3785 out, metadata, err = next.HandleDeserialize(ctx, in) 3786 if err != nil { 3787 return out, metadata, err 3788 } 3789 3790 response, ok := out.RawResponse.(*smithyhttp.Response) 3791 if !ok { 3792 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3793 } 3794 3795 if response.StatusCode < 200 || response.StatusCode >= 300 { 3796 return out, metadata, awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(response, &metadata) 3797 } 3798 output := &PutAccountSettingDefaultOutput{} 3799 out.Result = output 3800 3801 var buff [1024]byte 3802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3803 3804 body := io.TeeReader(response.Body, ringBuffer) 3805 decoder := json.NewDecoder(body) 3806 decoder.UseNumber() 3807 var shape interface{} 3808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3809 var snapshot bytes.Buffer 3810 io.Copy(&snapshot, ringBuffer) 3811 err = &smithy.DeserializationError{ 3812 Err: fmt.Errorf("failed to decode response body, %w", err), 3813 Snapshot: snapshot.Bytes(), 3814 } 3815 return out, metadata, err 3816 } 3817 3818 err = awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(&output, shape) 3819 if err != nil { 3820 var snapshot bytes.Buffer 3821 io.Copy(&snapshot, ringBuffer) 3822 err = &smithy.DeserializationError{ 3823 Err: fmt.Errorf("failed to decode response body, %w", err), 3824 Snapshot: snapshot.Bytes(), 3825 } 3826 return out, metadata, err 3827 } 3828 3829 return out, metadata, err 3830} 3831 3832func awsAwsjson11_deserializeOpErrorPutAccountSettingDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3833 var errorBuffer bytes.Buffer 3834 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3835 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3836 } 3837 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3838 3839 errorCode := "UnknownError" 3840 errorMessage := errorCode 3841 3842 code := response.Header.Get("X-Amzn-ErrorType") 3843 if len(code) != 0 { 3844 errorCode = restjson.SanitizeErrorCode(code) 3845 } 3846 3847 var buff [1024]byte 3848 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3849 3850 body := io.TeeReader(errorBody, ringBuffer) 3851 decoder := json.NewDecoder(body) 3852 decoder.UseNumber() 3853 code, message, err := restjson.GetErrorInfo(decoder) 3854 if err != nil { 3855 var snapshot bytes.Buffer 3856 io.Copy(&snapshot, ringBuffer) 3857 err = &smithy.DeserializationError{ 3858 Err: fmt.Errorf("failed to decode response body, %w", err), 3859 Snapshot: snapshot.Bytes(), 3860 } 3861 return err 3862 } 3863 3864 errorBody.Seek(0, io.SeekStart) 3865 if len(code) != 0 { 3866 errorCode = restjson.SanitizeErrorCode(code) 3867 } 3868 if len(message) != 0 { 3869 errorMessage = message 3870 } 3871 3872 switch { 3873 case strings.EqualFold("ClientException", errorCode): 3874 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 3875 3876 case strings.EqualFold("InvalidParameterException", errorCode): 3877 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3878 3879 case strings.EqualFold("ServerException", errorCode): 3880 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 3881 3882 default: 3883 genericError := &smithy.GenericAPIError{ 3884 Code: errorCode, 3885 Message: errorMessage, 3886 } 3887 return genericError 3888 3889 } 3890} 3891 3892type awsAwsjson11_deserializeOpPutAttributes struct { 3893} 3894 3895func (*awsAwsjson11_deserializeOpPutAttributes) ID() string { 3896 return "OperationDeserializer" 3897} 3898 3899func (m *awsAwsjson11_deserializeOpPutAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3900 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3901) { 3902 out, metadata, err = next.HandleDeserialize(ctx, in) 3903 if err != nil { 3904 return out, metadata, err 3905 } 3906 3907 response, ok := out.RawResponse.(*smithyhttp.Response) 3908 if !ok { 3909 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3910 } 3911 3912 if response.StatusCode < 200 || response.StatusCode >= 300 { 3913 return out, metadata, awsAwsjson11_deserializeOpErrorPutAttributes(response, &metadata) 3914 } 3915 output := &PutAttributesOutput{} 3916 out.Result = output 3917 3918 var buff [1024]byte 3919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3920 3921 body := io.TeeReader(response.Body, ringBuffer) 3922 decoder := json.NewDecoder(body) 3923 decoder.UseNumber() 3924 var shape interface{} 3925 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3926 var snapshot bytes.Buffer 3927 io.Copy(&snapshot, ringBuffer) 3928 err = &smithy.DeserializationError{ 3929 Err: fmt.Errorf("failed to decode response body, %w", err), 3930 Snapshot: snapshot.Bytes(), 3931 } 3932 return out, metadata, err 3933 } 3934 3935 err = awsAwsjson11_deserializeOpDocumentPutAttributesOutput(&output, shape) 3936 if err != nil { 3937 var snapshot bytes.Buffer 3938 io.Copy(&snapshot, ringBuffer) 3939 err = &smithy.DeserializationError{ 3940 Err: fmt.Errorf("failed to decode response body, %w", err), 3941 Snapshot: snapshot.Bytes(), 3942 } 3943 return out, metadata, err 3944 } 3945 3946 return out, metadata, err 3947} 3948 3949func awsAwsjson11_deserializeOpErrorPutAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3950 var errorBuffer bytes.Buffer 3951 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3952 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3953 } 3954 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3955 3956 errorCode := "UnknownError" 3957 errorMessage := errorCode 3958 3959 code := response.Header.Get("X-Amzn-ErrorType") 3960 if len(code) != 0 { 3961 errorCode = restjson.SanitizeErrorCode(code) 3962 } 3963 3964 var buff [1024]byte 3965 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3966 3967 body := io.TeeReader(errorBody, ringBuffer) 3968 decoder := json.NewDecoder(body) 3969 decoder.UseNumber() 3970 code, message, err := restjson.GetErrorInfo(decoder) 3971 if err != nil { 3972 var snapshot bytes.Buffer 3973 io.Copy(&snapshot, ringBuffer) 3974 err = &smithy.DeserializationError{ 3975 Err: fmt.Errorf("failed to decode response body, %w", err), 3976 Snapshot: snapshot.Bytes(), 3977 } 3978 return err 3979 } 3980 3981 errorBody.Seek(0, io.SeekStart) 3982 if len(code) != 0 { 3983 errorCode = restjson.SanitizeErrorCode(code) 3984 } 3985 if len(message) != 0 { 3986 errorMessage = message 3987 } 3988 3989 switch { 3990 case strings.EqualFold("AttributeLimitExceededException", errorCode): 3991 return awsAwsjson11_deserializeErrorAttributeLimitExceededException(response, errorBody) 3992 3993 case strings.EqualFold("ClusterNotFoundException", errorCode): 3994 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 3995 3996 case strings.EqualFold("InvalidParameterException", errorCode): 3997 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3998 3999 case strings.EqualFold("TargetNotFoundException", errorCode): 4000 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 4001 4002 default: 4003 genericError := &smithy.GenericAPIError{ 4004 Code: errorCode, 4005 Message: errorMessage, 4006 } 4007 return genericError 4008 4009 } 4010} 4011 4012type awsAwsjson11_deserializeOpPutClusterCapacityProviders struct { 4013} 4014 4015func (*awsAwsjson11_deserializeOpPutClusterCapacityProviders) ID() string { 4016 return "OperationDeserializer" 4017} 4018 4019func (m *awsAwsjson11_deserializeOpPutClusterCapacityProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4020 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4021) { 4022 out, metadata, err = next.HandleDeserialize(ctx, in) 4023 if err != nil { 4024 return out, metadata, err 4025 } 4026 4027 response, ok := out.RawResponse.(*smithyhttp.Response) 4028 if !ok { 4029 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4030 } 4031 4032 if response.StatusCode < 200 || response.StatusCode >= 300 { 4033 return out, metadata, awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(response, &metadata) 4034 } 4035 output := &PutClusterCapacityProvidersOutput{} 4036 out.Result = output 4037 4038 var buff [1024]byte 4039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4040 4041 body := io.TeeReader(response.Body, ringBuffer) 4042 decoder := json.NewDecoder(body) 4043 decoder.UseNumber() 4044 var shape interface{} 4045 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4046 var snapshot bytes.Buffer 4047 io.Copy(&snapshot, ringBuffer) 4048 err = &smithy.DeserializationError{ 4049 Err: fmt.Errorf("failed to decode response body, %w", err), 4050 Snapshot: snapshot.Bytes(), 4051 } 4052 return out, metadata, err 4053 } 4054 4055 err = awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(&output, shape) 4056 if err != nil { 4057 var snapshot bytes.Buffer 4058 io.Copy(&snapshot, ringBuffer) 4059 err = &smithy.DeserializationError{ 4060 Err: fmt.Errorf("failed to decode response body, %w", err), 4061 Snapshot: snapshot.Bytes(), 4062 } 4063 return out, metadata, err 4064 } 4065 4066 return out, metadata, err 4067} 4068 4069func awsAwsjson11_deserializeOpErrorPutClusterCapacityProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4070 var errorBuffer bytes.Buffer 4071 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4072 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4073 } 4074 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4075 4076 errorCode := "UnknownError" 4077 errorMessage := errorCode 4078 4079 code := response.Header.Get("X-Amzn-ErrorType") 4080 if len(code) != 0 { 4081 errorCode = restjson.SanitizeErrorCode(code) 4082 } 4083 4084 var buff [1024]byte 4085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4086 4087 body := io.TeeReader(errorBody, ringBuffer) 4088 decoder := json.NewDecoder(body) 4089 decoder.UseNumber() 4090 code, message, err := restjson.GetErrorInfo(decoder) 4091 if err != nil { 4092 var snapshot bytes.Buffer 4093 io.Copy(&snapshot, ringBuffer) 4094 err = &smithy.DeserializationError{ 4095 Err: fmt.Errorf("failed to decode response body, %w", err), 4096 Snapshot: snapshot.Bytes(), 4097 } 4098 return err 4099 } 4100 4101 errorBody.Seek(0, io.SeekStart) 4102 if len(code) != 0 { 4103 errorCode = restjson.SanitizeErrorCode(code) 4104 } 4105 if len(message) != 0 { 4106 errorMessage = message 4107 } 4108 4109 switch { 4110 case strings.EqualFold("ClientException", errorCode): 4111 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4112 4113 case strings.EqualFold("ClusterNotFoundException", errorCode): 4114 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 4115 4116 case strings.EqualFold("InvalidParameterException", errorCode): 4117 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4118 4119 case strings.EqualFold("ResourceInUseException", errorCode): 4120 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 4121 4122 case strings.EqualFold("ServerException", errorCode): 4123 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4124 4125 case strings.EqualFold("UpdateInProgressException", errorCode): 4126 return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody) 4127 4128 default: 4129 genericError := &smithy.GenericAPIError{ 4130 Code: errorCode, 4131 Message: errorMessage, 4132 } 4133 return genericError 4134 4135 } 4136} 4137 4138type awsAwsjson11_deserializeOpRegisterContainerInstance struct { 4139} 4140 4141func (*awsAwsjson11_deserializeOpRegisterContainerInstance) ID() string { 4142 return "OperationDeserializer" 4143} 4144 4145func (m *awsAwsjson11_deserializeOpRegisterContainerInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4146 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4147) { 4148 out, metadata, err = next.HandleDeserialize(ctx, in) 4149 if err != nil { 4150 return out, metadata, err 4151 } 4152 4153 response, ok := out.RawResponse.(*smithyhttp.Response) 4154 if !ok { 4155 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4156 } 4157 4158 if response.StatusCode < 200 || response.StatusCode >= 300 { 4159 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterContainerInstance(response, &metadata) 4160 } 4161 output := &RegisterContainerInstanceOutput{} 4162 out.Result = output 4163 4164 var buff [1024]byte 4165 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4166 4167 body := io.TeeReader(response.Body, ringBuffer) 4168 decoder := json.NewDecoder(body) 4169 decoder.UseNumber() 4170 var shape interface{} 4171 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4172 var snapshot bytes.Buffer 4173 io.Copy(&snapshot, ringBuffer) 4174 err = &smithy.DeserializationError{ 4175 Err: fmt.Errorf("failed to decode response body, %w", err), 4176 Snapshot: snapshot.Bytes(), 4177 } 4178 return out, metadata, err 4179 } 4180 4181 err = awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(&output, shape) 4182 if err != nil { 4183 var snapshot bytes.Buffer 4184 io.Copy(&snapshot, ringBuffer) 4185 err = &smithy.DeserializationError{ 4186 Err: fmt.Errorf("failed to decode response body, %w", err), 4187 Snapshot: snapshot.Bytes(), 4188 } 4189 return out, metadata, err 4190 } 4191 4192 return out, metadata, err 4193} 4194 4195func awsAwsjson11_deserializeOpErrorRegisterContainerInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4196 var errorBuffer bytes.Buffer 4197 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4198 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4199 } 4200 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4201 4202 errorCode := "UnknownError" 4203 errorMessage := errorCode 4204 4205 code := response.Header.Get("X-Amzn-ErrorType") 4206 if len(code) != 0 { 4207 errorCode = restjson.SanitizeErrorCode(code) 4208 } 4209 4210 var buff [1024]byte 4211 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4212 4213 body := io.TeeReader(errorBody, ringBuffer) 4214 decoder := json.NewDecoder(body) 4215 decoder.UseNumber() 4216 code, message, err := restjson.GetErrorInfo(decoder) 4217 if err != nil { 4218 var snapshot bytes.Buffer 4219 io.Copy(&snapshot, ringBuffer) 4220 err = &smithy.DeserializationError{ 4221 Err: fmt.Errorf("failed to decode response body, %w", err), 4222 Snapshot: snapshot.Bytes(), 4223 } 4224 return err 4225 } 4226 4227 errorBody.Seek(0, io.SeekStart) 4228 if len(code) != 0 { 4229 errorCode = restjson.SanitizeErrorCode(code) 4230 } 4231 if len(message) != 0 { 4232 errorMessage = message 4233 } 4234 4235 switch { 4236 case strings.EqualFold("ClientException", errorCode): 4237 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4238 4239 case strings.EqualFold("InvalidParameterException", errorCode): 4240 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4241 4242 case strings.EqualFold("ServerException", errorCode): 4243 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4244 4245 default: 4246 genericError := &smithy.GenericAPIError{ 4247 Code: errorCode, 4248 Message: errorMessage, 4249 } 4250 return genericError 4251 4252 } 4253} 4254 4255type awsAwsjson11_deserializeOpRegisterTaskDefinition struct { 4256} 4257 4258func (*awsAwsjson11_deserializeOpRegisterTaskDefinition) ID() string { 4259 return "OperationDeserializer" 4260} 4261 4262func (m *awsAwsjson11_deserializeOpRegisterTaskDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4263 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4264) { 4265 out, metadata, err = next.HandleDeserialize(ctx, in) 4266 if err != nil { 4267 return out, metadata, err 4268 } 4269 4270 response, ok := out.RawResponse.(*smithyhttp.Response) 4271 if !ok { 4272 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4273 } 4274 4275 if response.StatusCode < 200 || response.StatusCode >= 300 { 4276 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(response, &metadata) 4277 } 4278 output := &RegisterTaskDefinitionOutput{} 4279 out.Result = output 4280 4281 var buff [1024]byte 4282 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4283 4284 body := io.TeeReader(response.Body, ringBuffer) 4285 decoder := json.NewDecoder(body) 4286 decoder.UseNumber() 4287 var shape interface{} 4288 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4289 var snapshot bytes.Buffer 4290 io.Copy(&snapshot, ringBuffer) 4291 err = &smithy.DeserializationError{ 4292 Err: fmt.Errorf("failed to decode response body, %w", err), 4293 Snapshot: snapshot.Bytes(), 4294 } 4295 return out, metadata, err 4296 } 4297 4298 err = awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(&output, shape) 4299 if err != nil { 4300 var snapshot bytes.Buffer 4301 io.Copy(&snapshot, ringBuffer) 4302 err = &smithy.DeserializationError{ 4303 Err: fmt.Errorf("failed to decode response body, %w", err), 4304 Snapshot: snapshot.Bytes(), 4305 } 4306 return out, metadata, err 4307 } 4308 4309 return out, metadata, err 4310} 4311 4312func awsAwsjson11_deserializeOpErrorRegisterTaskDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4313 var errorBuffer bytes.Buffer 4314 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4315 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4316 } 4317 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4318 4319 errorCode := "UnknownError" 4320 errorMessage := errorCode 4321 4322 code := response.Header.Get("X-Amzn-ErrorType") 4323 if len(code) != 0 { 4324 errorCode = restjson.SanitizeErrorCode(code) 4325 } 4326 4327 var buff [1024]byte 4328 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4329 4330 body := io.TeeReader(errorBody, ringBuffer) 4331 decoder := json.NewDecoder(body) 4332 decoder.UseNumber() 4333 code, message, err := restjson.GetErrorInfo(decoder) 4334 if err != nil { 4335 var snapshot bytes.Buffer 4336 io.Copy(&snapshot, ringBuffer) 4337 err = &smithy.DeserializationError{ 4338 Err: fmt.Errorf("failed to decode response body, %w", err), 4339 Snapshot: snapshot.Bytes(), 4340 } 4341 return err 4342 } 4343 4344 errorBody.Seek(0, io.SeekStart) 4345 if len(code) != 0 { 4346 errorCode = restjson.SanitizeErrorCode(code) 4347 } 4348 if len(message) != 0 { 4349 errorMessage = message 4350 } 4351 4352 switch { 4353 case strings.EqualFold("ClientException", errorCode): 4354 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4355 4356 case strings.EqualFold("InvalidParameterException", errorCode): 4357 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4358 4359 case strings.EqualFold("ServerException", errorCode): 4360 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4361 4362 default: 4363 genericError := &smithy.GenericAPIError{ 4364 Code: errorCode, 4365 Message: errorMessage, 4366 } 4367 return genericError 4368 4369 } 4370} 4371 4372type awsAwsjson11_deserializeOpRunTask struct { 4373} 4374 4375func (*awsAwsjson11_deserializeOpRunTask) ID() string { 4376 return "OperationDeserializer" 4377} 4378 4379func (m *awsAwsjson11_deserializeOpRunTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4380 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4381) { 4382 out, metadata, err = next.HandleDeserialize(ctx, in) 4383 if err != nil { 4384 return out, metadata, err 4385 } 4386 4387 response, ok := out.RawResponse.(*smithyhttp.Response) 4388 if !ok { 4389 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4390 } 4391 4392 if response.StatusCode < 200 || response.StatusCode >= 300 { 4393 return out, metadata, awsAwsjson11_deserializeOpErrorRunTask(response, &metadata) 4394 } 4395 output := &RunTaskOutput{} 4396 out.Result = output 4397 4398 var buff [1024]byte 4399 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4400 4401 body := io.TeeReader(response.Body, ringBuffer) 4402 decoder := json.NewDecoder(body) 4403 decoder.UseNumber() 4404 var shape interface{} 4405 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4406 var snapshot bytes.Buffer 4407 io.Copy(&snapshot, ringBuffer) 4408 err = &smithy.DeserializationError{ 4409 Err: fmt.Errorf("failed to decode response body, %w", err), 4410 Snapshot: snapshot.Bytes(), 4411 } 4412 return out, metadata, err 4413 } 4414 4415 err = awsAwsjson11_deserializeOpDocumentRunTaskOutput(&output, shape) 4416 if err != nil { 4417 var snapshot bytes.Buffer 4418 io.Copy(&snapshot, ringBuffer) 4419 err = &smithy.DeserializationError{ 4420 Err: fmt.Errorf("failed to decode response body, %w", err), 4421 Snapshot: snapshot.Bytes(), 4422 } 4423 return out, metadata, err 4424 } 4425 4426 return out, metadata, err 4427} 4428 4429func awsAwsjson11_deserializeOpErrorRunTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4430 var errorBuffer bytes.Buffer 4431 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4432 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4433 } 4434 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4435 4436 errorCode := "UnknownError" 4437 errorMessage := errorCode 4438 4439 code := response.Header.Get("X-Amzn-ErrorType") 4440 if len(code) != 0 { 4441 errorCode = restjson.SanitizeErrorCode(code) 4442 } 4443 4444 var buff [1024]byte 4445 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4446 4447 body := io.TeeReader(errorBody, ringBuffer) 4448 decoder := json.NewDecoder(body) 4449 decoder.UseNumber() 4450 code, message, err := restjson.GetErrorInfo(decoder) 4451 if err != nil { 4452 var snapshot bytes.Buffer 4453 io.Copy(&snapshot, ringBuffer) 4454 err = &smithy.DeserializationError{ 4455 Err: fmt.Errorf("failed to decode response body, %w", err), 4456 Snapshot: snapshot.Bytes(), 4457 } 4458 return err 4459 } 4460 4461 errorBody.Seek(0, io.SeekStart) 4462 if len(code) != 0 { 4463 errorCode = restjson.SanitizeErrorCode(code) 4464 } 4465 if len(message) != 0 { 4466 errorMessage = message 4467 } 4468 4469 switch { 4470 case strings.EqualFold("AccessDeniedException", errorCode): 4471 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4472 4473 case strings.EqualFold("BlockedException", errorCode): 4474 return awsAwsjson11_deserializeErrorBlockedException(response, errorBody) 4475 4476 case strings.EqualFold("ClientException", errorCode): 4477 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4478 4479 case strings.EqualFold("ClusterNotFoundException", errorCode): 4480 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 4481 4482 case strings.EqualFold("InvalidParameterException", errorCode): 4483 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4484 4485 case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode): 4486 return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody) 4487 4488 case strings.EqualFold("PlatformUnknownException", errorCode): 4489 return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody) 4490 4491 case strings.EqualFold("ServerException", errorCode): 4492 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4493 4494 case strings.EqualFold("UnsupportedFeatureException", errorCode): 4495 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 4496 4497 default: 4498 genericError := &smithy.GenericAPIError{ 4499 Code: errorCode, 4500 Message: errorMessage, 4501 } 4502 return genericError 4503 4504 } 4505} 4506 4507type awsAwsjson11_deserializeOpStartTask struct { 4508} 4509 4510func (*awsAwsjson11_deserializeOpStartTask) ID() string { 4511 return "OperationDeserializer" 4512} 4513 4514func (m *awsAwsjson11_deserializeOpStartTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4515 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4516) { 4517 out, metadata, err = next.HandleDeserialize(ctx, in) 4518 if err != nil { 4519 return out, metadata, err 4520 } 4521 4522 response, ok := out.RawResponse.(*smithyhttp.Response) 4523 if !ok { 4524 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4525 } 4526 4527 if response.StatusCode < 200 || response.StatusCode >= 300 { 4528 return out, metadata, awsAwsjson11_deserializeOpErrorStartTask(response, &metadata) 4529 } 4530 output := &StartTaskOutput{} 4531 out.Result = output 4532 4533 var buff [1024]byte 4534 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4535 4536 body := io.TeeReader(response.Body, ringBuffer) 4537 decoder := json.NewDecoder(body) 4538 decoder.UseNumber() 4539 var shape interface{} 4540 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4541 var snapshot bytes.Buffer 4542 io.Copy(&snapshot, ringBuffer) 4543 err = &smithy.DeserializationError{ 4544 Err: fmt.Errorf("failed to decode response body, %w", err), 4545 Snapshot: snapshot.Bytes(), 4546 } 4547 return out, metadata, err 4548 } 4549 4550 err = awsAwsjson11_deserializeOpDocumentStartTaskOutput(&output, shape) 4551 if err != nil { 4552 var snapshot bytes.Buffer 4553 io.Copy(&snapshot, ringBuffer) 4554 err = &smithy.DeserializationError{ 4555 Err: fmt.Errorf("failed to decode response body, %w", err), 4556 Snapshot: snapshot.Bytes(), 4557 } 4558 return out, metadata, err 4559 } 4560 4561 return out, metadata, err 4562} 4563 4564func awsAwsjson11_deserializeOpErrorStartTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4565 var errorBuffer bytes.Buffer 4566 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4567 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4568 } 4569 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4570 4571 errorCode := "UnknownError" 4572 errorMessage := errorCode 4573 4574 code := response.Header.Get("X-Amzn-ErrorType") 4575 if len(code) != 0 { 4576 errorCode = restjson.SanitizeErrorCode(code) 4577 } 4578 4579 var buff [1024]byte 4580 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4581 4582 body := io.TeeReader(errorBody, ringBuffer) 4583 decoder := json.NewDecoder(body) 4584 decoder.UseNumber() 4585 code, message, err := restjson.GetErrorInfo(decoder) 4586 if err != nil { 4587 var snapshot bytes.Buffer 4588 io.Copy(&snapshot, ringBuffer) 4589 err = &smithy.DeserializationError{ 4590 Err: fmt.Errorf("failed to decode response body, %w", err), 4591 Snapshot: snapshot.Bytes(), 4592 } 4593 return err 4594 } 4595 4596 errorBody.Seek(0, io.SeekStart) 4597 if len(code) != 0 { 4598 errorCode = restjson.SanitizeErrorCode(code) 4599 } 4600 if len(message) != 0 { 4601 errorMessage = message 4602 } 4603 4604 switch { 4605 case strings.EqualFold("ClientException", errorCode): 4606 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4607 4608 case strings.EqualFold("ClusterNotFoundException", errorCode): 4609 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 4610 4611 case strings.EqualFold("InvalidParameterException", errorCode): 4612 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4613 4614 case strings.EqualFold("ServerException", errorCode): 4615 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4616 4617 default: 4618 genericError := &smithy.GenericAPIError{ 4619 Code: errorCode, 4620 Message: errorMessage, 4621 } 4622 return genericError 4623 4624 } 4625} 4626 4627type awsAwsjson11_deserializeOpStopTask struct { 4628} 4629 4630func (*awsAwsjson11_deserializeOpStopTask) ID() string { 4631 return "OperationDeserializer" 4632} 4633 4634func (m *awsAwsjson11_deserializeOpStopTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4636) { 4637 out, metadata, err = next.HandleDeserialize(ctx, in) 4638 if err != nil { 4639 return out, metadata, err 4640 } 4641 4642 response, ok := out.RawResponse.(*smithyhttp.Response) 4643 if !ok { 4644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4645 } 4646 4647 if response.StatusCode < 200 || response.StatusCode >= 300 { 4648 return out, metadata, awsAwsjson11_deserializeOpErrorStopTask(response, &metadata) 4649 } 4650 output := &StopTaskOutput{} 4651 out.Result = output 4652 4653 var buff [1024]byte 4654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4655 4656 body := io.TeeReader(response.Body, ringBuffer) 4657 decoder := json.NewDecoder(body) 4658 decoder.UseNumber() 4659 var shape interface{} 4660 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4661 var snapshot bytes.Buffer 4662 io.Copy(&snapshot, ringBuffer) 4663 err = &smithy.DeserializationError{ 4664 Err: fmt.Errorf("failed to decode response body, %w", err), 4665 Snapshot: snapshot.Bytes(), 4666 } 4667 return out, metadata, err 4668 } 4669 4670 err = awsAwsjson11_deserializeOpDocumentStopTaskOutput(&output, shape) 4671 if err != nil { 4672 var snapshot bytes.Buffer 4673 io.Copy(&snapshot, ringBuffer) 4674 err = &smithy.DeserializationError{ 4675 Err: fmt.Errorf("failed to decode response body, %w", err), 4676 Snapshot: snapshot.Bytes(), 4677 } 4678 return out, metadata, err 4679 } 4680 4681 return out, metadata, err 4682} 4683 4684func awsAwsjson11_deserializeOpErrorStopTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4685 var errorBuffer bytes.Buffer 4686 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4687 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4688 } 4689 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4690 4691 errorCode := "UnknownError" 4692 errorMessage := errorCode 4693 4694 code := response.Header.Get("X-Amzn-ErrorType") 4695 if len(code) != 0 { 4696 errorCode = restjson.SanitizeErrorCode(code) 4697 } 4698 4699 var buff [1024]byte 4700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4701 4702 body := io.TeeReader(errorBody, ringBuffer) 4703 decoder := json.NewDecoder(body) 4704 decoder.UseNumber() 4705 code, message, err := restjson.GetErrorInfo(decoder) 4706 if err != nil { 4707 var snapshot bytes.Buffer 4708 io.Copy(&snapshot, ringBuffer) 4709 err = &smithy.DeserializationError{ 4710 Err: fmt.Errorf("failed to decode response body, %w", err), 4711 Snapshot: snapshot.Bytes(), 4712 } 4713 return err 4714 } 4715 4716 errorBody.Seek(0, io.SeekStart) 4717 if len(code) != 0 { 4718 errorCode = restjson.SanitizeErrorCode(code) 4719 } 4720 if len(message) != 0 { 4721 errorMessage = message 4722 } 4723 4724 switch { 4725 case strings.EqualFold("ClientException", errorCode): 4726 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4727 4728 case strings.EqualFold("ClusterNotFoundException", errorCode): 4729 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 4730 4731 case strings.EqualFold("InvalidParameterException", errorCode): 4732 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4733 4734 case strings.EqualFold("ServerException", errorCode): 4735 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4736 4737 default: 4738 genericError := &smithy.GenericAPIError{ 4739 Code: errorCode, 4740 Message: errorMessage, 4741 } 4742 return genericError 4743 4744 } 4745} 4746 4747type awsAwsjson11_deserializeOpSubmitAttachmentStateChanges struct { 4748} 4749 4750func (*awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) ID() string { 4751 return "OperationDeserializer" 4752} 4753 4754func (m *awsAwsjson11_deserializeOpSubmitAttachmentStateChanges) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4755 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4756) { 4757 out, metadata, err = next.HandleDeserialize(ctx, in) 4758 if err != nil { 4759 return out, metadata, err 4760 } 4761 4762 response, ok := out.RawResponse.(*smithyhttp.Response) 4763 if !ok { 4764 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4765 } 4766 4767 if response.StatusCode < 200 || response.StatusCode >= 300 { 4768 return out, metadata, awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(response, &metadata) 4769 } 4770 output := &SubmitAttachmentStateChangesOutput{} 4771 out.Result = output 4772 4773 var buff [1024]byte 4774 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4775 4776 body := io.TeeReader(response.Body, ringBuffer) 4777 decoder := json.NewDecoder(body) 4778 decoder.UseNumber() 4779 var shape interface{} 4780 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4781 var snapshot bytes.Buffer 4782 io.Copy(&snapshot, ringBuffer) 4783 err = &smithy.DeserializationError{ 4784 Err: fmt.Errorf("failed to decode response body, %w", err), 4785 Snapshot: snapshot.Bytes(), 4786 } 4787 return out, metadata, err 4788 } 4789 4790 err = awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(&output, shape) 4791 if err != nil { 4792 var snapshot bytes.Buffer 4793 io.Copy(&snapshot, ringBuffer) 4794 err = &smithy.DeserializationError{ 4795 Err: fmt.Errorf("failed to decode response body, %w", err), 4796 Snapshot: snapshot.Bytes(), 4797 } 4798 return out, metadata, err 4799 } 4800 4801 return out, metadata, err 4802} 4803 4804func awsAwsjson11_deserializeOpErrorSubmitAttachmentStateChanges(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4805 var errorBuffer bytes.Buffer 4806 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4807 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4808 } 4809 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4810 4811 errorCode := "UnknownError" 4812 errorMessage := errorCode 4813 4814 code := response.Header.Get("X-Amzn-ErrorType") 4815 if len(code) != 0 { 4816 errorCode = restjson.SanitizeErrorCode(code) 4817 } 4818 4819 var buff [1024]byte 4820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4821 4822 body := io.TeeReader(errorBody, ringBuffer) 4823 decoder := json.NewDecoder(body) 4824 decoder.UseNumber() 4825 code, message, err := restjson.GetErrorInfo(decoder) 4826 if err != nil { 4827 var snapshot bytes.Buffer 4828 io.Copy(&snapshot, ringBuffer) 4829 err = &smithy.DeserializationError{ 4830 Err: fmt.Errorf("failed to decode response body, %w", err), 4831 Snapshot: snapshot.Bytes(), 4832 } 4833 return err 4834 } 4835 4836 errorBody.Seek(0, io.SeekStart) 4837 if len(code) != 0 { 4838 errorCode = restjson.SanitizeErrorCode(code) 4839 } 4840 if len(message) != 0 { 4841 errorMessage = message 4842 } 4843 4844 switch { 4845 case strings.EqualFold("AccessDeniedException", errorCode): 4846 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4847 4848 case strings.EqualFold("ClientException", errorCode): 4849 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4850 4851 case strings.EqualFold("InvalidParameterException", errorCode): 4852 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4853 4854 case strings.EqualFold("ServerException", errorCode): 4855 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4856 4857 default: 4858 genericError := &smithy.GenericAPIError{ 4859 Code: errorCode, 4860 Message: errorMessage, 4861 } 4862 return genericError 4863 4864 } 4865} 4866 4867type awsAwsjson11_deserializeOpSubmitContainerStateChange struct { 4868} 4869 4870func (*awsAwsjson11_deserializeOpSubmitContainerStateChange) ID() string { 4871 return "OperationDeserializer" 4872} 4873 4874func (m *awsAwsjson11_deserializeOpSubmitContainerStateChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4875 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4876) { 4877 out, metadata, err = next.HandleDeserialize(ctx, in) 4878 if err != nil { 4879 return out, metadata, err 4880 } 4881 4882 response, ok := out.RawResponse.(*smithyhttp.Response) 4883 if !ok { 4884 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4885 } 4886 4887 if response.StatusCode < 200 || response.StatusCode >= 300 { 4888 return out, metadata, awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(response, &metadata) 4889 } 4890 output := &SubmitContainerStateChangeOutput{} 4891 out.Result = output 4892 4893 var buff [1024]byte 4894 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4895 4896 body := io.TeeReader(response.Body, ringBuffer) 4897 decoder := json.NewDecoder(body) 4898 decoder.UseNumber() 4899 var shape interface{} 4900 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4901 var snapshot bytes.Buffer 4902 io.Copy(&snapshot, ringBuffer) 4903 err = &smithy.DeserializationError{ 4904 Err: fmt.Errorf("failed to decode response body, %w", err), 4905 Snapshot: snapshot.Bytes(), 4906 } 4907 return out, metadata, err 4908 } 4909 4910 err = awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(&output, shape) 4911 if err != nil { 4912 var snapshot bytes.Buffer 4913 io.Copy(&snapshot, ringBuffer) 4914 err = &smithy.DeserializationError{ 4915 Err: fmt.Errorf("failed to decode response body, %w", err), 4916 Snapshot: snapshot.Bytes(), 4917 } 4918 return out, metadata, err 4919 } 4920 4921 return out, metadata, err 4922} 4923 4924func awsAwsjson11_deserializeOpErrorSubmitContainerStateChange(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4925 var errorBuffer bytes.Buffer 4926 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4927 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4928 } 4929 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4930 4931 errorCode := "UnknownError" 4932 errorMessage := errorCode 4933 4934 code := response.Header.Get("X-Amzn-ErrorType") 4935 if len(code) != 0 { 4936 errorCode = restjson.SanitizeErrorCode(code) 4937 } 4938 4939 var buff [1024]byte 4940 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4941 4942 body := io.TeeReader(errorBody, ringBuffer) 4943 decoder := json.NewDecoder(body) 4944 decoder.UseNumber() 4945 code, message, err := restjson.GetErrorInfo(decoder) 4946 if err != nil { 4947 var snapshot bytes.Buffer 4948 io.Copy(&snapshot, ringBuffer) 4949 err = &smithy.DeserializationError{ 4950 Err: fmt.Errorf("failed to decode response body, %w", err), 4951 Snapshot: snapshot.Bytes(), 4952 } 4953 return err 4954 } 4955 4956 errorBody.Seek(0, io.SeekStart) 4957 if len(code) != 0 { 4958 errorCode = restjson.SanitizeErrorCode(code) 4959 } 4960 if len(message) != 0 { 4961 errorMessage = message 4962 } 4963 4964 switch { 4965 case strings.EqualFold("AccessDeniedException", errorCode): 4966 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4967 4968 case strings.EqualFold("ClientException", errorCode): 4969 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 4970 4971 case strings.EqualFold("ServerException", errorCode): 4972 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 4973 4974 default: 4975 genericError := &smithy.GenericAPIError{ 4976 Code: errorCode, 4977 Message: errorMessage, 4978 } 4979 return genericError 4980 4981 } 4982} 4983 4984type awsAwsjson11_deserializeOpSubmitTaskStateChange struct { 4985} 4986 4987func (*awsAwsjson11_deserializeOpSubmitTaskStateChange) ID() string { 4988 return "OperationDeserializer" 4989} 4990 4991func (m *awsAwsjson11_deserializeOpSubmitTaskStateChange) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4992 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4993) { 4994 out, metadata, err = next.HandleDeserialize(ctx, in) 4995 if err != nil { 4996 return out, metadata, err 4997 } 4998 4999 response, ok := out.RawResponse.(*smithyhttp.Response) 5000 if !ok { 5001 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5002 } 5003 5004 if response.StatusCode < 200 || response.StatusCode >= 300 { 5005 return out, metadata, awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(response, &metadata) 5006 } 5007 output := &SubmitTaskStateChangeOutput{} 5008 out.Result = output 5009 5010 var buff [1024]byte 5011 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5012 5013 body := io.TeeReader(response.Body, ringBuffer) 5014 decoder := json.NewDecoder(body) 5015 decoder.UseNumber() 5016 var shape interface{} 5017 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5018 var snapshot bytes.Buffer 5019 io.Copy(&snapshot, ringBuffer) 5020 err = &smithy.DeserializationError{ 5021 Err: fmt.Errorf("failed to decode response body, %w", err), 5022 Snapshot: snapshot.Bytes(), 5023 } 5024 return out, metadata, err 5025 } 5026 5027 err = awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(&output, shape) 5028 if err != nil { 5029 var snapshot bytes.Buffer 5030 io.Copy(&snapshot, ringBuffer) 5031 err = &smithy.DeserializationError{ 5032 Err: fmt.Errorf("failed to decode response body, %w", err), 5033 Snapshot: snapshot.Bytes(), 5034 } 5035 return out, metadata, err 5036 } 5037 5038 return out, metadata, err 5039} 5040 5041func awsAwsjson11_deserializeOpErrorSubmitTaskStateChange(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5042 var errorBuffer bytes.Buffer 5043 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5044 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5045 } 5046 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5047 5048 errorCode := "UnknownError" 5049 errorMessage := errorCode 5050 5051 code := response.Header.Get("X-Amzn-ErrorType") 5052 if len(code) != 0 { 5053 errorCode = restjson.SanitizeErrorCode(code) 5054 } 5055 5056 var buff [1024]byte 5057 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5058 5059 body := io.TeeReader(errorBody, ringBuffer) 5060 decoder := json.NewDecoder(body) 5061 decoder.UseNumber() 5062 code, message, err := restjson.GetErrorInfo(decoder) 5063 if err != nil { 5064 var snapshot bytes.Buffer 5065 io.Copy(&snapshot, ringBuffer) 5066 err = &smithy.DeserializationError{ 5067 Err: fmt.Errorf("failed to decode response body, %w", err), 5068 Snapshot: snapshot.Bytes(), 5069 } 5070 return err 5071 } 5072 5073 errorBody.Seek(0, io.SeekStart) 5074 if len(code) != 0 { 5075 errorCode = restjson.SanitizeErrorCode(code) 5076 } 5077 if len(message) != 0 { 5078 errorMessage = message 5079 } 5080 5081 switch { 5082 case strings.EqualFold("AccessDeniedException", errorCode): 5083 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5084 5085 case strings.EqualFold("ClientException", errorCode): 5086 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5087 5088 case strings.EqualFold("InvalidParameterException", errorCode): 5089 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5090 5091 case strings.EqualFold("ServerException", errorCode): 5092 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5093 5094 default: 5095 genericError := &smithy.GenericAPIError{ 5096 Code: errorCode, 5097 Message: errorMessage, 5098 } 5099 return genericError 5100 5101 } 5102} 5103 5104type awsAwsjson11_deserializeOpTagResource struct { 5105} 5106 5107func (*awsAwsjson11_deserializeOpTagResource) ID() string { 5108 return "OperationDeserializer" 5109} 5110 5111func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5112 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5113) { 5114 out, metadata, err = next.HandleDeserialize(ctx, in) 5115 if err != nil { 5116 return out, metadata, err 5117 } 5118 5119 response, ok := out.RawResponse.(*smithyhttp.Response) 5120 if !ok { 5121 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5122 } 5123 5124 if response.StatusCode < 200 || response.StatusCode >= 300 { 5125 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 5126 } 5127 output := &TagResourceOutput{} 5128 out.Result = output 5129 5130 var buff [1024]byte 5131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5132 5133 body := io.TeeReader(response.Body, ringBuffer) 5134 decoder := json.NewDecoder(body) 5135 decoder.UseNumber() 5136 var shape interface{} 5137 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5138 var snapshot bytes.Buffer 5139 io.Copy(&snapshot, ringBuffer) 5140 err = &smithy.DeserializationError{ 5141 Err: fmt.Errorf("failed to decode response body, %w", err), 5142 Snapshot: snapshot.Bytes(), 5143 } 5144 return out, metadata, err 5145 } 5146 5147 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 5148 if err != nil { 5149 var snapshot bytes.Buffer 5150 io.Copy(&snapshot, ringBuffer) 5151 err = &smithy.DeserializationError{ 5152 Err: fmt.Errorf("failed to decode response body, %w", err), 5153 Snapshot: snapshot.Bytes(), 5154 } 5155 return out, metadata, err 5156 } 5157 5158 return out, metadata, err 5159} 5160 5161func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5162 var errorBuffer bytes.Buffer 5163 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5164 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5165 } 5166 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5167 5168 errorCode := "UnknownError" 5169 errorMessage := errorCode 5170 5171 code := response.Header.Get("X-Amzn-ErrorType") 5172 if len(code) != 0 { 5173 errorCode = restjson.SanitizeErrorCode(code) 5174 } 5175 5176 var buff [1024]byte 5177 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5178 5179 body := io.TeeReader(errorBody, ringBuffer) 5180 decoder := json.NewDecoder(body) 5181 decoder.UseNumber() 5182 code, message, err := restjson.GetErrorInfo(decoder) 5183 if err != nil { 5184 var snapshot bytes.Buffer 5185 io.Copy(&snapshot, ringBuffer) 5186 err = &smithy.DeserializationError{ 5187 Err: fmt.Errorf("failed to decode response body, %w", err), 5188 Snapshot: snapshot.Bytes(), 5189 } 5190 return err 5191 } 5192 5193 errorBody.Seek(0, io.SeekStart) 5194 if len(code) != 0 { 5195 errorCode = restjson.SanitizeErrorCode(code) 5196 } 5197 if len(message) != 0 { 5198 errorMessage = message 5199 } 5200 5201 switch { 5202 case strings.EqualFold("ClientException", errorCode): 5203 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5204 5205 case strings.EqualFold("ClusterNotFoundException", errorCode): 5206 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5207 5208 case strings.EqualFold("InvalidParameterException", errorCode): 5209 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5210 5211 case strings.EqualFold("ResourceNotFoundException", errorCode): 5212 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5213 5214 case strings.EqualFold("ServerException", errorCode): 5215 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5216 5217 default: 5218 genericError := &smithy.GenericAPIError{ 5219 Code: errorCode, 5220 Message: errorMessage, 5221 } 5222 return genericError 5223 5224 } 5225} 5226 5227type awsAwsjson11_deserializeOpUntagResource struct { 5228} 5229 5230func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 5231 return "OperationDeserializer" 5232} 5233 5234func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5235 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5236) { 5237 out, metadata, err = next.HandleDeserialize(ctx, in) 5238 if err != nil { 5239 return out, metadata, err 5240 } 5241 5242 response, ok := out.RawResponse.(*smithyhttp.Response) 5243 if !ok { 5244 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5245 } 5246 5247 if response.StatusCode < 200 || response.StatusCode >= 300 { 5248 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 5249 } 5250 output := &UntagResourceOutput{} 5251 out.Result = output 5252 5253 var buff [1024]byte 5254 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5255 5256 body := io.TeeReader(response.Body, ringBuffer) 5257 decoder := json.NewDecoder(body) 5258 decoder.UseNumber() 5259 var shape interface{} 5260 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5261 var snapshot bytes.Buffer 5262 io.Copy(&snapshot, ringBuffer) 5263 err = &smithy.DeserializationError{ 5264 Err: fmt.Errorf("failed to decode response body, %w", err), 5265 Snapshot: snapshot.Bytes(), 5266 } 5267 return out, metadata, err 5268 } 5269 5270 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 5271 if err != nil { 5272 var snapshot bytes.Buffer 5273 io.Copy(&snapshot, ringBuffer) 5274 err = &smithy.DeserializationError{ 5275 Err: fmt.Errorf("failed to decode response body, %w", err), 5276 Snapshot: snapshot.Bytes(), 5277 } 5278 return out, metadata, err 5279 } 5280 5281 return out, metadata, err 5282} 5283 5284func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5285 var errorBuffer bytes.Buffer 5286 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5287 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5288 } 5289 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5290 5291 errorCode := "UnknownError" 5292 errorMessage := errorCode 5293 5294 code := response.Header.Get("X-Amzn-ErrorType") 5295 if len(code) != 0 { 5296 errorCode = restjson.SanitizeErrorCode(code) 5297 } 5298 5299 var buff [1024]byte 5300 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5301 5302 body := io.TeeReader(errorBody, ringBuffer) 5303 decoder := json.NewDecoder(body) 5304 decoder.UseNumber() 5305 code, message, err := restjson.GetErrorInfo(decoder) 5306 if err != nil { 5307 var snapshot bytes.Buffer 5308 io.Copy(&snapshot, ringBuffer) 5309 err = &smithy.DeserializationError{ 5310 Err: fmt.Errorf("failed to decode response body, %w", err), 5311 Snapshot: snapshot.Bytes(), 5312 } 5313 return err 5314 } 5315 5316 errorBody.Seek(0, io.SeekStart) 5317 if len(code) != 0 { 5318 errorCode = restjson.SanitizeErrorCode(code) 5319 } 5320 if len(message) != 0 { 5321 errorMessage = message 5322 } 5323 5324 switch { 5325 case strings.EqualFold("ClientException", errorCode): 5326 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5327 5328 case strings.EqualFold("ClusterNotFoundException", errorCode): 5329 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5330 5331 case strings.EqualFold("InvalidParameterException", errorCode): 5332 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5333 5334 case strings.EqualFold("ResourceNotFoundException", errorCode): 5335 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5336 5337 case strings.EqualFold("ServerException", errorCode): 5338 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5339 5340 default: 5341 genericError := &smithy.GenericAPIError{ 5342 Code: errorCode, 5343 Message: errorMessage, 5344 } 5345 return genericError 5346 5347 } 5348} 5349 5350type awsAwsjson11_deserializeOpUpdateCapacityProvider struct { 5351} 5352 5353func (*awsAwsjson11_deserializeOpUpdateCapacityProvider) ID() string { 5354 return "OperationDeserializer" 5355} 5356 5357func (m *awsAwsjson11_deserializeOpUpdateCapacityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5358 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5359) { 5360 out, metadata, err = next.HandleDeserialize(ctx, in) 5361 if err != nil { 5362 return out, metadata, err 5363 } 5364 5365 response, ok := out.RawResponse.(*smithyhttp.Response) 5366 if !ok { 5367 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5368 } 5369 5370 if response.StatusCode < 200 || response.StatusCode >= 300 { 5371 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(response, &metadata) 5372 } 5373 output := &UpdateCapacityProviderOutput{} 5374 out.Result = output 5375 5376 var buff [1024]byte 5377 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5378 5379 body := io.TeeReader(response.Body, ringBuffer) 5380 decoder := json.NewDecoder(body) 5381 decoder.UseNumber() 5382 var shape interface{} 5383 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5384 var snapshot bytes.Buffer 5385 io.Copy(&snapshot, ringBuffer) 5386 err = &smithy.DeserializationError{ 5387 Err: fmt.Errorf("failed to decode response body, %w", err), 5388 Snapshot: snapshot.Bytes(), 5389 } 5390 return out, metadata, err 5391 } 5392 5393 err = awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(&output, shape) 5394 if err != nil { 5395 var snapshot bytes.Buffer 5396 io.Copy(&snapshot, ringBuffer) 5397 err = &smithy.DeserializationError{ 5398 Err: fmt.Errorf("failed to decode response body, %w", err), 5399 Snapshot: snapshot.Bytes(), 5400 } 5401 return out, metadata, err 5402 } 5403 5404 return out, metadata, err 5405} 5406 5407func awsAwsjson11_deserializeOpErrorUpdateCapacityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5408 var errorBuffer bytes.Buffer 5409 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5410 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5411 } 5412 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5413 5414 errorCode := "UnknownError" 5415 errorMessage := errorCode 5416 5417 code := response.Header.Get("X-Amzn-ErrorType") 5418 if len(code) != 0 { 5419 errorCode = restjson.SanitizeErrorCode(code) 5420 } 5421 5422 var buff [1024]byte 5423 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5424 5425 body := io.TeeReader(errorBody, ringBuffer) 5426 decoder := json.NewDecoder(body) 5427 decoder.UseNumber() 5428 code, message, err := restjson.GetErrorInfo(decoder) 5429 if err != nil { 5430 var snapshot bytes.Buffer 5431 io.Copy(&snapshot, ringBuffer) 5432 err = &smithy.DeserializationError{ 5433 Err: fmt.Errorf("failed to decode response body, %w", err), 5434 Snapshot: snapshot.Bytes(), 5435 } 5436 return err 5437 } 5438 5439 errorBody.Seek(0, io.SeekStart) 5440 if len(code) != 0 { 5441 errorCode = restjson.SanitizeErrorCode(code) 5442 } 5443 if len(message) != 0 { 5444 errorMessage = message 5445 } 5446 5447 switch { 5448 case strings.EqualFold("ClientException", errorCode): 5449 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5450 5451 case strings.EqualFold("InvalidParameterException", errorCode): 5452 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5453 5454 case strings.EqualFold("ServerException", errorCode): 5455 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5456 5457 default: 5458 genericError := &smithy.GenericAPIError{ 5459 Code: errorCode, 5460 Message: errorMessage, 5461 } 5462 return genericError 5463 5464 } 5465} 5466 5467type awsAwsjson11_deserializeOpUpdateCluster struct { 5468} 5469 5470func (*awsAwsjson11_deserializeOpUpdateCluster) ID() string { 5471 return "OperationDeserializer" 5472} 5473 5474func (m *awsAwsjson11_deserializeOpUpdateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5475 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5476) { 5477 out, metadata, err = next.HandleDeserialize(ctx, in) 5478 if err != nil { 5479 return out, metadata, err 5480 } 5481 5482 response, ok := out.RawResponse.(*smithyhttp.Response) 5483 if !ok { 5484 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5485 } 5486 5487 if response.StatusCode < 200 || response.StatusCode >= 300 { 5488 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateCluster(response, &metadata) 5489 } 5490 output := &UpdateClusterOutput{} 5491 out.Result = output 5492 5493 var buff [1024]byte 5494 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5495 5496 body := io.TeeReader(response.Body, ringBuffer) 5497 decoder := json.NewDecoder(body) 5498 decoder.UseNumber() 5499 var shape interface{} 5500 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5501 var snapshot bytes.Buffer 5502 io.Copy(&snapshot, ringBuffer) 5503 err = &smithy.DeserializationError{ 5504 Err: fmt.Errorf("failed to decode response body, %w", err), 5505 Snapshot: snapshot.Bytes(), 5506 } 5507 return out, metadata, err 5508 } 5509 5510 err = awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(&output, shape) 5511 if err != nil { 5512 var snapshot bytes.Buffer 5513 io.Copy(&snapshot, ringBuffer) 5514 err = &smithy.DeserializationError{ 5515 Err: fmt.Errorf("failed to decode response body, %w", err), 5516 Snapshot: snapshot.Bytes(), 5517 } 5518 return out, metadata, err 5519 } 5520 5521 return out, metadata, err 5522} 5523 5524func awsAwsjson11_deserializeOpErrorUpdateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5525 var errorBuffer bytes.Buffer 5526 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5527 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5528 } 5529 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5530 5531 errorCode := "UnknownError" 5532 errorMessage := errorCode 5533 5534 code := response.Header.Get("X-Amzn-ErrorType") 5535 if len(code) != 0 { 5536 errorCode = restjson.SanitizeErrorCode(code) 5537 } 5538 5539 var buff [1024]byte 5540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5541 5542 body := io.TeeReader(errorBody, ringBuffer) 5543 decoder := json.NewDecoder(body) 5544 decoder.UseNumber() 5545 code, message, err := restjson.GetErrorInfo(decoder) 5546 if err != nil { 5547 var snapshot bytes.Buffer 5548 io.Copy(&snapshot, ringBuffer) 5549 err = &smithy.DeserializationError{ 5550 Err: fmt.Errorf("failed to decode response body, %w", err), 5551 Snapshot: snapshot.Bytes(), 5552 } 5553 return err 5554 } 5555 5556 errorBody.Seek(0, io.SeekStart) 5557 if len(code) != 0 { 5558 errorCode = restjson.SanitizeErrorCode(code) 5559 } 5560 if len(message) != 0 { 5561 errorMessage = message 5562 } 5563 5564 switch { 5565 case strings.EqualFold("ClientException", errorCode): 5566 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5567 5568 case strings.EqualFold("ClusterNotFoundException", errorCode): 5569 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5570 5571 case strings.EqualFold("InvalidParameterException", errorCode): 5572 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5573 5574 case strings.EqualFold("ServerException", errorCode): 5575 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5576 5577 default: 5578 genericError := &smithy.GenericAPIError{ 5579 Code: errorCode, 5580 Message: errorMessage, 5581 } 5582 return genericError 5583 5584 } 5585} 5586 5587type awsAwsjson11_deserializeOpUpdateClusterSettings struct { 5588} 5589 5590func (*awsAwsjson11_deserializeOpUpdateClusterSettings) ID() string { 5591 return "OperationDeserializer" 5592} 5593 5594func (m *awsAwsjson11_deserializeOpUpdateClusterSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5595 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5596) { 5597 out, metadata, err = next.HandleDeserialize(ctx, in) 5598 if err != nil { 5599 return out, metadata, err 5600 } 5601 5602 response, ok := out.RawResponse.(*smithyhttp.Response) 5603 if !ok { 5604 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5605 } 5606 5607 if response.StatusCode < 200 || response.StatusCode >= 300 { 5608 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateClusterSettings(response, &metadata) 5609 } 5610 output := &UpdateClusterSettingsOutput{} 5611 out.Result = output 5612 5613 var buff [1024]byte 5614 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5615 5616 body := io.TeeReader(response.Body, ringBuffer) 5617 decoder := json.NewDecoder(body) 5618 decoder.UseNumber() 5619 var shape interface{} 5620 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5621 var snapshot bytes.Buffer 5622 io.Copy(&snapshot, ringBuffer) 5623 err = &smithy.DeserializationError{ 5624 Err: fmt.Errorf("failed to decode response body, %w", err), 5625 Snapshot: snapshot.Bytes(), 5626 } 5627 return out, metadata, err 5628 } 5629 5630 err = awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(&output, shape) 5631 if err != nil { 5632 var snapshot bytes.Buffer 5633 io.Copy(&snapshot, ringBuffer) 5634 err = &smithy.DeserializationError{ 5635 Err: fmt.Errorf("failed to decode response body, %w", err), 5636 Snapshot: snapshot.Bytes(), 5637 } 5638 return out, metadata, err 5639 } 5640 5641 return out, metadata, err 5642} 5643 5644func awsAwsjson11_deserializeOpErrorUpdateClusterSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5645 var errorBuffer bytes.Buffer 5646 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5647 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5648 } 5649 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5650 5651 errorCode := "UnknownError" 5652 errorMessage := errorCode 5653 5654 code := response.Header.Get("X-Amzn-ErrorType") 5655 if len(code) != 0 { 5656 errorCode = restjson.SanitizeErrorCode(code) 5657 } 5658 5659 var buff [1024]byte 5660 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5661 5662 body := io.TeeReader(errorBody, ringBuffer) 5663 decoder := json.NewDecoder(body) 5664 decoder.UseNumber() 5665 code, message, err := restjson.GetErrorInfo(decoder) 5666 if err != nil { 5667 var snapshot bytes.Buffer 5668 io.Copy(&snapshot, ringBuffer) 5669 err = &smithy.DeserializationError{ 5670 Err: fmt.Errorf("failed to decode response body, %w", err), 5671 Snapshot: snapshot.Bytes(), 5672 } 5673 return err 5674 } 5675 5676 errorBody.Seek(0, io.SeekStart) 5677 if len(code) != 0 { 5678 errorCode = restjson.SanitizeErrorCode(code) 5679 } 5680 if len(message) != 0 { 5681 errorMessage = message 5682 } 5683 5684 switch { 5685 case strings.EqualFold("ClientException", errorCode): 5686 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5687 5688 case strings.EqualFold("ClusterNotFoundException", errorCode): 5689 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5690 5691 case strings.EqualFold("InvalidParameterException", errorCode): 5692 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5693 5694 case strings.EqualFold("ServerException", errorCode): 5695 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5696 5697 default: 5698 genericError := &smithy.GenericAPIError{ 5699 Code: errorCode, 5700 Message: errorMessage, 5701 } 5702 return genericError 5703 5704 } 5705} 5706 5707type awsAwsjson11_deserializeOpUpdateContainerAgent struct { 5708} 5709 5710func (*awsAwsjson11_deserializeOpUpdateContainerAgent) ID() string { 5711 return "OperationDeserializer" 5712} 5713 5714func (m *awsAwsjson11_deserializeOpUpdateContainerAgent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5715 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5716) { 5717 out, metadata, err = next.HandleDeserialize(ctx, in) 5718 if err != nil { 5719 return out, metadata, err 5720 } 5721 5722 response, ok := out.RawResponse.(*smithyhttp.Response) 5723 if !ok { 5724 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5725 } 5726 5727 if response.StatusCode < 200 || response.StatusCode >= 300 { 5728 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerAgent(response, &metadata) 5729 } 5730 output := &UpdateContainerAgentOutput{} 5731 out.Result = output 5732 5733 var buff [1024]byte 5734 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5735 5736 body := io.TeeReader(response.Body, ringBuffer) 5737 decoder := json.NewDecoder(body) 5738 decoder.UseNumber() 5739 var shape interface{} 5740 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5741 var snapshot bytes.Buffer 5742 io.Copy(&snapshot, ringBuffer) 5743 err = &smithy.DeserializationError{ 5744 Err: fmt.Errorf("failed to decode response body, %w", err), 5745 Snapshot: snapshot.Bytes(), 5746 } 5747 return out, metadata, err 5748 } 5749 5750 err = awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(&output, shape) 5751 if err != nil { 5752 var snapshot bytes.Buffer 5753 io.Copy(&snapshot, ringBuffer) 5754 err = &smithy.DeserializationError{ 5755 Err: fmt.Errorf("failed to decode response body, %w", err), 5756 Snapshot: snapshot.Bytes(), 5757 } 5758 return out, metadata, err 5759 } 5760 5761 return out, metadata, err 5762} 5763 5764func awsAwsjson11_deserializeOpErrorUpdateContainerAgent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5765 var errorBuffer bytes.Buffer 5766 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5767 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5768 } 5769 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5770 5771 errorCode := "UnknownError" 5772 errorMessage := errorCode 5773 5774 code := response.Header.Get("X-Amzn-ErrorType") 5775 if len(code) != 0 { 5776 errorCode = restjson.SanitizeErrorCode(code) 5777 } 5778 5779 var buff [1024]byte 5780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5781 5782 body := io.TeeReader(errorBody, ringBuffer) 5783 decoder := json.NewDecoder(body) 5784 decoder.UseNumber() 5785 code, message, err := restjson.GetErrorInfo(decoder) 5786 if err != nil { 5787 var snapshot bytes.Buffer 5788 io.Copy(&snapshot, ringBuffer) 5789 err = &smithy.DeserializationError{ 5790 Err: fmt.Errorf("failed to decode response body, %w", err), 5791 Snapshot: snapshot.Bytes(), 5792 } 5793 return err 5794 } 5795 5796 errorBody.Seek(0, io.SeekStart) 5797 if len(code) != 0 { 5798 errorCode = restjson.SanitizeErrorCode(code) 5799 } 5800 if len(message) != 0 { 5801 errorMessage = message 5802 } 5803 5804 switch { 5805 case strings.EqualFold("ClientException", errorCode): 5806 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5807 5808 case strings.EqualFold("ClusterNotFoundException", errorCode): 5809 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5810 5811 case strings.EqualFold("InvalidParameterException", errorCode): 5812 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5813 5814 case strings.EqualFold("MissingVersionException", errorCode): 5815 return awsAwsjson11_deserializeErrorMissingVersionException(response, errorBody) 5816 5817 case strings.EqualFold("NoUpdateAvailableException", errorCode): 5818 return awsAwsjson11_deserializeErrorNoUpdateAvailableException(response, errorBody) 5819 5820 case strings.EqualFold("ServerException", errorCode): 5821 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5822 5823 case strings.EqualFold("UpdateInProgressException", errorCode): 5824 return awsAwsjson11_deserializeErrorUpdateInProgressException(response, errorBody) 5825 5826 default: 5827 genericError := &smithy.GenericAPIError{ 5828 Code: errorCode, 5829 Message: errorMessage, 5830 } 5831 return genericError 5832 5833 } 5834} 5835 5836type awsAwsjson11_deserializeOpUpdateContainerInstancesState struct { 5837} 5838 5839func (*awsAwsjson11_deserializeOpUpdateContainerInstancesState) ID() string { 5840 return "OperationDeserializer" 5841} 5842 5843func (m *awsAwsjson11_deserializeOpUpdateContainerInstancesState) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5844 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5845) { 5846 out, metadata, err = next.HandleDeserialize(ctx, in) 5847 if err != nil { 5848 return out, metadata, err 5849 } 5850 5851 response, ok := out.RawResponse.(*smithyhttp.Response) 5852 if !ok { 5853 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5854 } 5855 5856 if response.StatusCode < 200 || response.StatusCode >= 300 { 5857 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(response, &metadata) 5858 } 5859 output := &UpdateContainerInstancesStateOutput{} 5860 out.Result = output 5861 5862 var buff [1024]byte 5863 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5864 5865 body := io.TeeReader(response.Body, ringBuffer) 5866 decoder := json.NewDecoder(body) 5867 decoder.UseNumber() 5868 var shape interface{} 5869 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5870 var snapshot bytes.Buffer 5871 io.Copy(&snapshot, ringBuffer) 5872 err = &smithy.DeserializationError{ 5873 Err: fmt.Errorf("failed to decode response body, %w", err), 5874 Snapshot: snapshot.Bytes(), 5875 } 5876 return out, metadata, err 5877 } 5878 5879 err = awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(&output, shape) 5880 if err != nil { 5881 var snapshot bytes.Buffer 5882 io.Copy(&snapshot, ringBuffer) 5883 err = &smithy.DeserializationError{ 5884 Err: fmt.Errorf("failed to decode response body, %w", err), 5885 Snapshot: snapshot.Bytes(), 5886 } 5887 return out, metadata, err 5888 } 5889 5890 return out, metadata, err 5891} 5892 5893func awsAwsjson11_deserializeOpErrorUpdateContainerInstancesState(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5894 var errorBuffer bytes.Buffer 5895 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5896 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5897 } 5898 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5899 5900 errorCode := "UnknownError" 5901 errorMessage := errorCode 5902 5903 code := response.Header.Get("X-Amzn-ErrorType") 5904 if len(code) != 0 { 5905 errorCode = restjson.SanitizeErrorCode(code) 5906 } 5907 5908 var buff [1024]byte 5909 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5910 5911 body := io.TeeReader(errorBody, ringBuffer) 5912 decoder := json.NewDecoder(body) 5913 decoder.UseNumber() 5914 code, message, err := restjson.GetErrorInfo(decoder) 5915 if err != nil { 5916 var snapshot bytes.Buffer 5917 io.Copy(&snapshot, ringBuffer) 5918 err = &smithy.DeserializationError{ 5919 Err: fmt.Errorf("failed to decode response body, %w", err), 5920 Snapshot: snapshot.Bytes(), 5921 } 5922 return err 5923 } 5924 5925 errorBody.Seek(0, io.SeekStart) 5926 if len(code) != 0 { 5927 errorCode = restjson.SanitizeErrorCode(code) 5928 } 5929 if len(message) != 0 { 5930 errorMessage = message 5931 } 5932 5933 switch { 5934 case strings.EqualFold("ClientException", errorCode): 5935 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 5936 5937 case strings.EqualFold("ClusterNotFoundException", errorCode): 5938 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 5939 5940 case strings.EqualFold("InvalidParameterException", errorCode): 5941 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 5942 5943 case strings.EqualFold("ServerException", errorCode): 5944 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 5945 5946 default: 5947 genericError := &smithy.GenericAPIError{ 5948 Code: errorCode, 5949 Message: errorMessage, 5950 } 5951 return genericError 5952 5953 } 5954} 5955 5956type awsAwsjson11_deserializeOpUpdateService struct { 5957} 5958 5959func (*awsAwsjson11_deserializeOpUpdateService) ID() string { 5960 return "OperationDeserializer" 5961} 5962 5963func (m *awsAwsjson11_deserializeOpUpdateService) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5964 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5965) { 5966 out, metadata, err = next.HandleDeserialize(ctx, in) 5967 if err != nil { 5968 return out, metadata, err 5969 } 5970 5971 response, ok := out.RawResponse.(*smithyhttp.Response) 5972 if !ok { 5973 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5974 } 5975 5976 if response.StatusCode < 200 || response.StatusCode >= 300 { 5977 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateService(response, &metadata) 5978 } 5979 output := &UpdateServiceOutput{} 5980 out.Result = output 5981 5982 var buff [1024]byte 5983 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5984 5985 body := io.TeeReader(response.Body, ringBuffer) 5986 decoder := json.NewDecoder(body) 5987 decoder.UseNumber() 5988 var shape interface{} 5989 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5990 var snapshot bytes.Buffer 5991 io.Copy(&snapshot, ringBuffer) 5992 err = &smithy.DeserializationError{ 5993 Err: fmt.Errorf("failed to decode response body, %w", err), 5994 Snapshot: snapshot.Bytes(), 5995 } 5996 return out, metadata, err 5997 } 5998 5999 err = awsAwsjson11_deserializeOpDocumentUpdateServiceOutput(&output, shape) 6000 if err != nil { 6001 var snapshot bytes.Buffer 6002 io.Copy(&snapshot, ringBuffer) 6003 err = &smithy.DeserializationError{ 6004 Err: fmt.Errorf("failed to decode response body, %w", err), 6005 Snapshot: snapshot.Bytes(), 6006 } 6007 return out, metadata, err 6008 } 6009 6010 return out, metadata, err 6011} 6012 6013func awsAwsjson11_deserializeOpErrorUpdateService(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6014 var errorBuffer bytes.Buffer 6015 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6016 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6017 } 6018 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6019 6020 errorCode := "UnknownError" 6021 errorMessage := errorCode 6022 6023 code := response.Header.Get("X-Amzn-ErrorType") 6024 if len(code) != 0 { 6025 errorCode = restjson.SanitizeErrorCode(code) 6026 } 6027 6028 var buff [1024]byte 6029 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6030 6031 body := io.TeeReader(errorBody, ringBuffer) 6032 decoder := json.NewDecoder(body) 6033 decoder.UseNumber() 6034 code, message, err := restjson.GetErrorInfo(decoder) 6035 if err != nil { 6036 var snapshot bytes.Buffer 6037 io.Copy(&snapshot, ringBuffer) 6038 err = &smithy.DeserializationError{ 6039 Err: fmt.Errorf("failed to decode response body, %w", err), 6040 Snapshot: snapshot.Bytes(), 6041 } 6042 return err 6043 } 6044 6045 errorBody.Seek(0, io.SeekStart) 6046 if len(code) != 0 { 6047 errorCode = restjson.SanitizeErrorCode(code) 6048 } 6049 if len(message) != 0 { 6050 errorMessage = message 6051 } 6052 6053 switch { 6054 case strings.EqualFold("AccessDeniedException", errorCode): 6055 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6056 6057 case strings.EqualFold("ClientException", errorCode): 6058 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 6059 6060 case strings.EqualFold("ClusterNotFoundException", errorCode): 6061 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 6062 6063 case strings.EqualFold("InvalidParameterException", errorCode): 6064 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6065 6066 case strings.EqualFold("PlatformTaskDefinitionIncompatibilityException", errorCode): 6067 return awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response, errorBody) 6068 6069 case strings.EqualFold("PlatformUnknownException", errorCode): 6070 return awsAwsjson11_deserializeErrorPlatformUnknownException(response, errorBody) 6071 6072 case strings.EqualFold("ServerException", errorCode): 6073 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 6074 6075 case strings.EqualFold("ServiceNotActiveException", errorCode): 6076 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 6077 6078 case strings.EqualFold("ServiceNotFoundException", errorCode): 6079 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 6080 6081 default: 6082 genericError := &smithy.GenericAPIError{ 6083 Code: errorCode, 6084 Message: errorMessage, 6085 } 6086 return genericError 6087 6088 } 6089} 6090 6091type awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet struct { 6092} 6093 6094func (*awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) ID() string { 6095 return "OperationDeserializer" 6096} 6097 6098func (m *awsAwsjson11_deserializeOpUpdateServicePrimaryTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6099 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6100) { 6101 out, metadata, err = next.HandleDeserialize(ctx, in) 6102 if err != nil { 6103 return out, metadata, err 6104 } 6105 6106 response, ok := out.RawResponse.(*smithyhttp.Response) 6107 if !ok { 6108 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6109 } 6110 6111 if response.StatusCode < 200 || response.StatusCode >= 300 { 6112 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(response, &metadata) 6113 } 6114 output := &UpdateServicePrimaryTaskSetOutput{} 6115 out.Result = output 6116 6117 var buff [1024]byte 6118 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6119 6120 body := io.TeeReader(response.Body, ringBuffer) 6121 decoder := json.NewDecoder(body) 6122 decoder.UseNumber() 6123 var shape interface{} 6124 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6125 var snapshot bytes.Buffer 6126 io.Copy(&snapshot, ringBuffer) 6127 err = &smithy.DeserializationError{ 6128 Err: fmt.Errorf("failed to decode response body, %w", err), 6129 Snapshot: snapshot.Bytes(), 6130 } 6131 return out, metadata, err 6132 } 6133 6134 err = awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(&output, shape) 6135 if err != nil { 6136 var snapshot bytes.Buffer 6137 io.Copy(&snapshot, ringBuffer) 6138 err = &smithy.DeserializationError{ 6139 Err: fmt.Errorf("failed to decode response body, %w", err), 6140 Snapshot: snapshot.Bytes(), 6141 } 6142 return out, metadata, err 6143 } 6144 6145 return out, metadata, err 6146} 6147 6148func awsAwsjson11_deserializeOpErrorUpdateServicePrimaryTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6149 var errorBuffer bytes.Buffer 6150 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6151 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6152 } 6153 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6154 6155 errorCode := "UnknownError" 6156 errorMessage := errorCode 6157 6158 code := response.Header.Get("X-Amzn-ErrorType") 6159 if len(code) != 0 { 6160 errorCode = restjson.SanitizeErrorCode(code) 6161 } 6162 6163 var buff [1024]byte 6164 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6165 6166 body := io.TeeReader(errorBody, ringBuffer) 6167 decoder := json.NewDecoder(body) 6168 decoder.UseNumber() 6169 code, message, err := restjson.GetErrorInfo(decoder) 6170 if err != nil { 6171 var snapshot bytes.Buffer 6172 io.Copy(&snapshot, ringBuffer) 6173 err = &smithy.DeserializationError{ 6174 Err: fmt.Errorf("failed to decode response body, %w", err), 6175 Snapshot: snapshot.Bytes(), 6176 } 6177 return err 6178 } 6179 6180 errorBody.Seek(0, io.SeekStart) 6181 if len(code) != 0 { 6182 errorCode = restjson.SanitizeErrorCode(code) 6183 } 6184 if len(message) != 0 { 6185 errorMessage = message 6186 } 6187 6188 switch { 6189 case strings.EqualFold("AccessDeniedException", errorCode): 6190 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6191 6192 case strings.EqualFold("ClientException", errorCode): 6193 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 6194 6195 case strings.EqualFold("ClusterNotFoundException", errorCode): 6196 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 6197 6198 case strings.EqualFold("InvalidParameterException", errorCode): 6199 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6200 6201 case strings.EqualFold("ServerException", errorCode): 6202 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 6203 6204 case strings.EqualFold("ServiceNotActiveException", errorCode): 6205 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 6206 6207 case strings.EqualFold("ServiceNotFoundException", errorCode): 6208 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 6209 6210 case strings.EqualFold("TaskSetNotFoundException", errorCode): 6211 return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody) 6212 6213 case strings.EqualFold("UnsupportedFeatureException", errorCode): 6214 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 6215 6216 default: 6217 genericError := &smithy.GenericAPIError{ 6218 Code: errorCode, 6219 Message: errorMessage, 6220 } 6221 return genericError 6222 6223 } 6224} 6225 6226type awsAwsjson11_deserializeOpUpdateTaskSet struct { 6227} 6228 6229func (*awsAwsjson11_deserializeOpUpdateTaskSet) ID() string { 6230 return "OperationDeserializer" 6231} 6232 6233func (m *awsAwsjson11_deserializeOpUpdateTaskSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6234 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6235) { 6236 out, metadata, err = next.HandleDeserialize(ctx, in) 6237 if err != nil { 6238 return out, metadata, err 6239 } 6240 6241 response, ok := out.RawResponse.(*smithyhttp.Response) 6242 if !ok { 6243 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6244 } 6245 6246 if response.StatusCode < 200 || response.StatusCode >= 300 { 6247 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTaskSet(response, &metadata) 6248 } 6249 output := &UpdateTaskSetOutput{} 6250 out.Result = output 6251 6252 var buff [1024]byte 6253 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6254 6255 body := io.TeeReader(response.Body, ringBuffer) 6256 decoder := json.NewDecoder(body) 6257 decoder.UseNumber() 6258 var shape interface{} 6259 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6260 var snapshot bytes.Buffer 6261 io.Copy(&snapshot, ringBuffer) 6262 err = &smithy.DeserializationError{ 6263 Err: fmt.Errorf("failed to decode response body, %w", err), 6264 Snapshot: snapshot.Bytes(), 6265 } 6266 return out, metadata, err 6267 } 6268 6269 err = awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(&output, shape) 6270 if err != nil { 6271 var snapshot bytes.Buffer 6272 io.Copy(&snapshot, ringBuffer) 6273 err = &smithy.DeserializationError{ 6274 Err: fmt.Errorf("failed to decode response body, %w", err), 6275 Snapshot: snapshot.Bytes(), 6276 } 6277 return out, metadata, err 6278 } 6279 6280 return out, metadata, err 6281} 6282 6283func awsAwsjson11_deserializeOpErrorUpdateTaskSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6284 var errorBuffer bytes.Buffer 6285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6287 } 6288 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6289 6290 errorCode := "UnknownError" 6291 errorMessage := errorCode 6292 6293 code := response.Header.Get("X-Amzn-ErrorType") 6294 if len(code) != 0 { 6295 errorCode = restjson.SanitizeErrorCode(code) 6296 } 6297 6298 var buff [1024]byte 6299 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6300 6301 body := io.TeeReader(errorBody, ringBuffer) 6302 decoder := json.NewDecoder(body) 6303 decoder.UseNumber() 6304 code, message, err := restjson.GetErrorInfo(decoder) 6305 if err != nil { 6306 var snapshot bytes.Buffer 6307 io.Copy(&snapshot, ringBuffer) 6308 err = &smithy.DeserializationError{ 6309 Err: fmt.Errorf("failed to decode response body, %w", err), 6310 Snapshot: snapshot.Bytes(), 6311 } 6312 return err 6313 } 6314 6315 errorBody.Seek(0, io.SeekStart) 6316 if len(code) != 0 { 6317 errorCode = restjson.SanitizeErrorCode(code) 6318 } 6319 if len(message) != 0 { 6320 errorMessage = message 6321 } 6322 6323 switch { 6324 case strings.EqualFold("AccessDeniedException", errorCode): 6325 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6326 6327 case strings.EqualFold("ClientException", errorCode): 6328 return awsAwsjson11_deserializeErrorClientException(response, errorBody) 6329 6330 case strings.EqualFold("ClusterNotFoundException", errorCode): 6331 return awsAwsjson11_deserializeErrorClusterNotFoundException(response, errorBody) 6332 6333 case strings.EqualFold("InvalidParameterException", errorCode): 6334 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 6335 6336 case strings.EqualFold("ServerException", errorCode): 6337 return awsAwsjson11_deserializeErrorServerException(response, errorBody) 6338 6339 case strings.EqualFold("ServiceNotActiveException", errorCode): 6340 return awsAwsjson11_deserializeErrorServiceNotActiveException(response, errorBody) 6341 6342 case strings.EqualFold("ServiceNotFoundException", errorCode): 6343 return awsAwsjson11_deserializeErrorServiceNotFoundException(response, errorBody) 6344 6345 case strings.EqualFold("TaskSetNotFoundException", errorCode): 6346 return awsAwsjson11_deserializeErrorTaskSetNotFoundException(response, errorBody) 6347 6348 case strings.EqualFold("UnsupportedFeatureException", errorCode): 6349 return awsAwsjson11_deserializeErrorUnsupportedFeatureException(response, errorBody) 6350 6351 default: 6352 genericError := &smithy.GenericAPIError{ 6353 Code: errorCode, 6354 Message: errorMessage, 6355 } 6356 return genericError 6357 6358 } 6359} 6360 6361func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6362 var buff [1024]byte 6363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6364 6365 body := io.TeeReader(errorBody, ringBuffer) 6366 decoder := json.NewDecoder(body) 6367 decoder.UseNumber() 6368 var shape interface{} 6369 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6370 var snapshot bytes.Buffer 6371 io.Copy(&snapshot, ringBuffer) 6372 err = &smithy.DeserializationError{ 6373 Err: fmt.Errorf("failed to decode response body, %w", err), 6374 Snapshot: snapshot.Bytes(), 6375 } 6376 return err 6377 } 6378 6379 output := &types.AccessDeniedException{} 6380 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 6381 6382 if err != nil { 6383 var snapshot bytes.Buffer 6384 io.Copy(&snapshot, ringBuffer) 6385 err = &smithy.DeserializationError{ 6386 Err: fmt.Errorf("failed to decode response body, %w", err), 6387 Snapshot: snapshot.Bytes(), 6388 } 6389 return err 6390 } 6391 6392 errorBody.Seek(0, io.SeekStart) 6393 return output 6394} 6395 6396func awsAwsjson11_deserializeErrorAttributeLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6397 var buff [1024]byte 6398 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6399 6400 body := io.TeeReader(errorBody, ringBuffer) 6401 decoder := json.NewDecoder(body) 6402 decoder.UseNumber() 6403 var shape interface{} 6404 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6405 var snapshot bytes.Buffer 6406 io.Copy(&snapshot, ringBuffer) 6407 err = &smithy.DeserializationError{ 6408 Err: fmt.Errorf("failed to decode response body, %w", err), 6409 Snapshot: snapshot.Bytes(), 6410 } 6411 return err 6412 } 6413 6414 output := &types.AttributeLimitExceededException{} 6415 err := awsAwsjson11_deserializeDocumentAttributeLimitExceededException(&output, shape) 6416 6417 if err != nil { 6418 var snapshot bytes.Buffer 6419 io.Copy(&snapshot, ringBuffer) 6420 err = &smithy.DeserializationError{ 6421 Err: fmt.Errorf("failed to decode response body, %w", err), 6422 Snapshot: snapshot.Bytes(), 6423 } 6424 return err 6425 } 6426 6427 errorBody.Seek(0, io.SeekStart) 6428 return output 6429} 6430 6431func awsAwsjson11_deserializeErrorBlockedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6432 var buff [1024]byte 6433 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6434 6435 body := io.TeeReader(errorBody, ringBuffer) 6436 decoder := json.NewDecoder(body) 6437 decoder.UseNumber() 6438 var shape interface{} 6439 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6440 var snapshot bytes.Buffer 6441 io.Copy(&snapshot, ringBuffer) 6442 err = &smithy.DeserializationError{ 6443 Err: fmt.Errorf("failed to decode response body, %w", err), 6444 Snapshot: snapshot.Bytes(), 6445 } 6446 return err 6447 } 6448 6449 output := &types.BlockedException{} 6450 err := awsAwsjson11_deserializeDocumentBlockedException(&output, shape) 6451 6452 if err != nil { 6453 var snapshot bytes.Buffer 6454 io.Copy(&snapshot, ringBuffer) 6455 err = &smithy.DeserializationError{ 6456 Err: fmt.Errorf("failed to decode response body, %w", err), 6457 Snapshot: snapshot.Bytes(), 6458 } 6459 return err 6460 } 6461 6462 errorBody.Seek(0, io.SeekStart) 6463 return output 6464} 6465 6466func awsAwsjson11_deserializeErrorClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6467 var buff [1024]byte 6468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6469 6470 body := io.TeeReader(errorBody, ringBuffer) 6471 decoder := json.NewDecoder(body) 6472 decoder.UseNumber() 6473 var shape interface{} 6474 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6475 var snapshot bytes.Buffer 6476 io.Copy(&snapshot, ringBuffer) 6477 err = &smithy.DeserializationError{ 6478 Err: fmt.Errorf("failed to decode response body, %w", err), 6479 Snapshot: snapshot.Bytes(), 6480 } 6481 return err 6482 } 6483 6484 output := &types.ClientException{} 6485 err := awsAwsjson11_deserializeDocumentClientException(&output, shape) 6486 6487 if err != nil { 6488 var snapshot bytes.Buffer 6489 io.Copy(&snapshot, ringBuffer) 6490 err = &smithy.DeserializationError{ 6491 Err: fmt.Errorf("failed to decode response body, %w", err), 6492 Snapshot: snapshot.Bytes(), 6493 } 6494 return err 6495 } 6496 6497 errorBody.Seek(0, io.SeekStart) 6498 return output 6499} 6500 6501func awsAwsjson11_deserializeErrorClusterContainsContainerInstancesException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6502 var buff [1024]byte 6503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6504 6505 body := io.TeeReader(errorBody, ringBuffer) 6506 decoder := json.NewDecoder(body) 6507 decoder.UseNumber() 6508 var shape interface{} 6509 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6510 var snapshot bytes.Buffer 6511 io.Copy(&snapshot, ringBuffer) 6512 err = &smithy.DeserializationError{ 6513 Err: fmt.Errorf("failed to decode response body, %w", err), 6514 Snapshot: snapshot.Bytes(), 6515 } 6516 return err 6517 } 6518 6519 output := &types.ClusterContainsContainerInstancesException{} 6520 err := awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(&output, shape) 6521 6522 if err != nil { 6523 var snapshot bytes.Buffer 6524 io.Copy(&snapshot, ringBuffer) 6525 err = &smithy.DeserializationError{ 6526 Err: fmt.Errorf("failed to decode response body, %w", err), 6527 Snapshot: snapshot.Bytes(), 6528 } 6529 return err 6530 } 6531 6532 errorBody.Seek(0, io.SeekStart) 6533 return output 6534} 6535 6536func awsAwsjson11_deserializeErrorClusterContainsServicesException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6537 var buff [1024]byte 6538 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6539 6540 body := io.TeeReader(errorBody, ringBuffer) 6541 decoder := json.NewDecoder(body) 6542 decoder.UseNumber() 6543 var shape interface{} 6544 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6545 var snapshot bytes.Buffer 6546 io.Copy(&snapshot, ringBuffer) 6547 err = &smithy.DeserializationError{ 6548 Err: fmt.Errorf("failed to decode response body, %w", err), 6549 Snapshot: snapshot.Bytes(), 6550 } 6551 return err 6552 } 6553 6554 output := &types.ClusterContainsServicesException{} 6555 err := awsAwsjson11_deserializeDocumentClusterContainsServicesException(&output, shape) 6556 6557 if err != nil { 6558 var snapshot bytes.Buffer 6559 io.Copy(&snapshot, ringBuffer) 6560 err = &smithy.DeserializationError{ 6561 Err: fmt.Errorf("failed to decode response body, %w", err), 6562 Snapshot: snapshot.Bytes(), 6563 } 6564 return err 6565 } 6566 6567 errorBody.Seek(0, io.SeekStart) 6568 return output 6569} 6570 6571func awsAwsjson11_deserializeErrorClusterContainsTasksException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6572 var buff [1024]byte 6573 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6574 6575 body := io.TeeReader(errorBody, ringBuffer) 6576 decoder := json.NewDecoder(body) 6577 decoder.UseNumber() 6578 var shape interface{} 6579 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6580 var snapshot bytes.Buffer 6581 io.Copy(&snapshot, ringBuffer) 6582 err = &smithy.DeserializationError{ 6583 Err: fmt.Errorf("failed to decode response body, %w", err), 6584 Snapshot: snapshot.Bytes(), 6585 } 6586 return err 6587 } 6588 6589 output := &types.ClusterContainsTasksException{} 6590 err := awsAwsjson11_deserializeDocumentClusterContainsTasksException(&output, shape) 6591 6592 if err != nil { 6593 var snapshot bytes.Buffer 6594 io.Copy(&snapshot, ringBuffer) 6595 err = &smithy.DeserializationError{ 6596 Err: fmt.Errorf("failed to decode response body, %w", err), 6597 Snapshot: snapshot.Bytes(), 6598 } 6599 return err 6600 } 6601 6602 errorBody.Seek(0, io.SeekStart) 6603 return output 6604} 6605 6606func awsAwsjson11_deserializeErrorClusterNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6607 var buff [1024]byte 6608 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6609 6610 body := io.TeeReader(errorBody, ringBuffer) 6611 decoder := json.NewDecoder(body) 6612 decoder.UseNumber() 6613 var shape interface{} 6614 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6615 var snapshot bytes.Buffer 6616 io.Copy(&snapshot, ringBuffer) 6617 err = &smithy.DeserializationError{ 6618 Err: fmt.Errorf("failed to decode response body, %w", err), 6619 Snapshot: snapshot.Bytes(), 6620 } 6621 return err 6622 } 6623 6624 output := &types.ClusterNotFoundException{} 6625 err := awsAwsjson11_deserializeDocumentClusterNotFoundException(&output, shape) 6626 6627 if err != nil { 6628 var snapshot bytes.Buffer 6629 io.Copy(&snapshot, ringBuffer) 6630 err = &smithy.DeserializationError{ 6631 Err: fmt.Errorf("failed to decode response body, %w", err), 6632 Snapshot: snapshot.Bytes(), 6633 } 6634 return err 6635 } 6636 6637 errorBody.Seek(0, io.SeekStart) 6638 return output 6639} 6640 6641func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6642 var buff [1024]byte 6643 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6644 6645 body := io.TeeReader(errorBody, ringBuffer) 6646 decoder := json.NewDecoder(body) 6647 decoder.UseNumber() 6648 var shape interface{} 6649 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6650 var snapshot bytes.Buffer 6651 io.Copy(&snapshot, ringBuffer) 6652 err = &smithy.DeserializationError{ 6653 Err: fmt.Errorf("failed to decode response body, %w", err), 6654 Snapshot: snapshot.Bytes(), 6655 } 6656 return err 6657 } 6658 6659 output := &types.InvalidParameterException{} 6660 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 6661 6662 if err != nil { 6663 var snapshot bytes.Buffer 6664 io.Copy(&snapshot, ringBuffer) 6665 err = &smithy.DeserializationError{ 6666 Err: fmt.Errorf("failed to decode response body, %w", err), 6667 Snapshot: snapshot.Bytes(), 6668 } 6669 return err 6670 } 6671 6672 errorBody.Seek(0, io.SeekStart) 6673 return output 6674} 6675 6676func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6677 var buff [1024]byte 6678 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6679 6680 body := io.TeeReader(errorBody, ringBuffer) 6681 decoder := json.NewDecoder(body) 6682 decoder.UseNumber() 6683 var shape interface{} 6684 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6685 var snapshot bytes.Buffer 6686 io.Copy(&snapshot, ringBuffer) 6687 err = &smithy.DeserializationError{ 6688 Err: fmt.Errorf("failed to decode response body, %w", err), 6689 Snapshot: snapshot.Bytes(), 6690 } 6691 return err 6692 } 6693 6694 output := &types.LimitExceededException{} 6695 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 6696 6697 if err != nil { 6698 var snapshot bytes.Buffer 6699 io.Copy(&snapshot, ringBuffer) 6700 err = &smithy.DeserializationError{ 6701 Err: fmt.Errorf("failed to decode response body, %w", err), 6702 Snapshot: snapshot.Bytes(), 6703 } 6704 return err 6705 } 6706 6707 errorBody.Seek(0, io.SeekStart) 6708 return output 6709} 6710 6711func awsAwsjson11_deserializeErrorMissingVersionException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6712 var buff [1024]byte 6713 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6714 6715 body := io.TeeReader(errorBody, ringBuffer) 6716 decoder := json.NewDecoder(body) 6717 decoder.UseNumber() 6718 var shape interface{} 6719 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6720 var snapshot bytes.Buffer 6721 io.Copy(&snapshot, ringBuffer) 6722 err = &smithy.DeserializationError{ 6723 Err: fmt.Errorf("failed to decode response body, %w", err), 6724 Snapshot: snapshot.Bytes(), 6725 } 6726 return err 6727 } 6728 6729 output := &types.MissingVersionException{} 6730 err := awsAwsjson11_deserializeDocumentMissingVersionException(&output, shape) 6731 6732 if err != nil { 6733 var snapshot bytes.Buffer 6734 io.Copy(&snapshot, ringBuffer) 6735 err = &smithy.DeserializationError{ 6736 Err: fmt.Errorf("failed to decode response body, %w", err), 6737 Snapshot: snapshot.Bytes(), 6738 } 6739 return err 6740 } 6741 6742 errorBody.Seek(0, io.SeekStart) 6743 return output 6744} 6745 6746func awsAwsjson11_deserializeErrorNoUpdateAvailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6747 var buff [1024]byte 6748 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6749 6750 body := io.TeeReader(errorBody, ringBuffer) 6751 decoder := json.NewDecoder(body) 6752 decoder.UseNumber() 6753 var shape interface{} 6754 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6755 var snapshot bytes.Buffer 6756 io.Copy(&snapshot, ringBuffer) 6757 err = &smithy.DeserializationError{ 6758 Err: fmt.Errorf("failed to decode response body, %w", err), 6759 Snapshot: snapshot.Bytes(), 6760 } 6761 return err 6762 } 6763 6764 output := &types.NoUpdateAvailableException{} 6765 err := awsAwsjson11_deserializeDocumentNoUpdateAvailableException(&output, shape) 6766 6767 if err != nil { 6768 var snapshot bytes.Buffer 6769 io.Copy(&snapshot, ringBuffer) 6770 err = &smithy.DeserializationError{ 6771 Err: fmt.Errorf("failed to decode response body, %w", err), 6772 Snapshot: snapshot.Bytes(), 6773 } 6774 return err 6775 } 6776 6777 errorBody.Seek(0, io.SeekStart) 6778 return output 6779} 6780 6781func awsAwsjson11_deserializeErrorPlatformTaskDefinitionIncompatibilityException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6782 var buff [1024]byte 6783 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6784 6785 body := io.TeeReader(errorBody, ringBuffer) 6786 decoder := json.NewDecoder(body) 6787 decoder.UseNumber() 6788 var shape interface{} 6789 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6790 var snapshot bytes.Buffer 6791 io.Copy(&snapshot, ringBuffer) 6792 err = &smithy.DeserializationError{ 6793 Err: fmt.Errorf("failed to decode response body, %w", err), 6794 Snapshot: snapshot.Bytes(), 6795 } 6796 return err 6797 } 6798 6799 output := &types.PlatformTaskDefinitionIncompatibilityException{} 6800 err := awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(&output, shape) 6801 6802 if err != nil { 6803 var snapshot bytes.Buffer 6804 io.Copy(&snapshot, ringBuffer) 6805 err = &smithy.DeserializationError{ 6806 Err: fmt.Errorf("failed to decode response body, %w", err), 6807 Snapshot: snapshot.Bytes(), 6808 } 6809 return err 6810 } 6811 6812 errorBody.Seek(0, io.SeekStart) 6813 return output 6814} 6815 6816func awsAwsjson11_deserializeErrorPlatformUnknownException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6817 var buff [1024]byte 6818 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6819 6820 body := io.TeeReader(errorBody, ringBuffer) 6821 decoder := json.NewDecoder(body) 6822 decoder.UseNumber() 6823 var shape interface{} 6824 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6825 var snapshot bytes.Buffer 6826 io.Copy(&snapshot, ringBuffer) 6827 err = &smithy.DeserializationError{ 6828 Err: fmt.Errorf("failed to decode response body, %w", err), 6829 Snapshot: snapshot.Bytes(), 6830 } 6831 return err 6832 } 6833 6834 output := &types.PlatformUnknownException{} 6835 err := awsAwsjson11_deserializeDocumentPlatformUnknownException(&output, shape) 6836 6837 if err != nil { 6838 var snapshot bytes.Buffer 6839 io.Copy(&snapshot, ringBuffer) 6840 err = &smithy.DeserializationError{ 6841 Err: fmt.Errorf("failed to decode response body, %w", err), 6842 Snapshot: snapshot.Bytes(), 6843 } 6844 return err 6845 } 6846 6847 errorBody.Seek(0, io.SeekStart) 6848 return output 6849} 6850 6851func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6852 var buff [1024]byte 6853 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6854 6855 body := io.TeeReader(errorBody, ringBuffer) 6856 decoder := json.NewDecoder(body) 6857 decoder.UseNumber() 6858 var shape interface{} 6859 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6860 var snapshot bytes.Buffer 6861 io.Copy(&snapshot, ringBuffer) 6862 err = &smithy.DeserializationError{ 6863 Err: fmt.Errorf("failed to decode response body, %w", err), 6864 Snapshot: snapshot.Bytes(), 6865 } 6866 return err 6867 } 6868 6869 output := &types.ResourceInUseException{} 6870 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 6871 6872 if err != nil { 6873 var snapshot bytes.Buffer 6874 io.Copy(&snapshot, ringBuffer) 6875 err = &smithy.DeserializationError{ 6876 Err: fmt.Errorf("failed to decode response body, %w", err), 6877 Snapshot: snapshot.Bytes(), 6878 } 6879 return err 6880 } 6881 6882 errorBody.Seek(0, io.SeekStart) 6883 return output 6884} 6885 6886func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6887 var buff [1024]byte 6888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6889 6890 body := io.TeeReader(errorBody, ringBuffer) 6891 decoder := json.NewDecoder(body) 6892 decoder.UseNumber() 6893 var shape interface{} 6894 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6895 var snapshot bytes.Buffer 6896 io.Copy(&snapshot, ringBuffer) 6897 err = &smithy.DeserializationError{ 6898 Err: fmt.Errorf("failed to decode response body, %w", err), 6899 Snapshot: snapshot.Bytes(), 6900 } 6901 return err 6902 } 6903 6904 output := &types.ResourceNotFoundException{} 6905 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 6906 6907 if err != nil { 6908 var snapshot bytes.Buffer 6909 io.Copy(&snapshot, ringBuffer) 6910 err = &smithy.DeserializationError{ 6911 Err: fmt.Errorf("failed to decode response body, %w", err), 6912 Snapshot: snapshot.Bytes(), 6913 } 6914 return err 6915 } 6916 6917 errorBody.Seek(0, io.SeekStart) 6918 return output 6919} 6920 6921func awsAwsjson11_deserializeErrorServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6922 var buff [1024]byte 6923 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6924 6925 body := io.TeeReader(errorBody, ringBuffer) 6926 decoder := json.NewDecoder(body) 6927 decoder.UseNumber() 6928 var shape interface{} 6929 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6930 var snapshot bytes.Buffer 6931 io.Copy(&snapshot, ringBuffer) 6932 err = &smithy.DeserializationError{ 6933 Err: fmt.Errorf("failed to decode response body, %w", err), 6934 Snapshot: snapshot.Bytes(), 6935 } 6936 return err 6937 } 6938 6939 output := &types.ServerException{} 6940 err := awsAwsjson11_deserializeDocumentServerException(&output, shape) 6941 6942 if err != nil { 6943 var snapshot bytes.Buffer 6944 io.Copy(&snapshot, ringBuffer) 6945 err = &smithy.DeserializationError{ 6946 Err: fmt.Errorf("failed to decode response body, %w", err), 6947 Snapshot: snapshot.Bytes(), 6948 } 6949 return err 6950 } 6951 6952 errorBody.Seek(0, io.SeekStart) 6953 return output 6954} 6955 6956func awsAwsjson11_deserializeErrorServiceNotActiveException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6957 var buff [1024]byte 6958 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6959 6960 body := io.TeeReader(errorBody, ringBuffer) 6961 decoder := json.NewDecoder(body) 6962 decoder.UseNumber() 6963 var shape interface{} 6964 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6965 var snapshot bytes.Buffer 6966 io.Copy(&snapshot, ringBuffer) 6967 err = &smithy.DeserializationError{ 6968 Err: fmt.Errorf("failed to decode response body, %w", err), 6969 Snapshot: snapshot.Bytes(), 6970 } 6971 return err 6972 } 6973 6974 output := &types.ServiceNotActiveException{} 6975 err := awsAwsjson11_deserializeDocumentServiceNotActiveException(&output, shape) 6976 6977 if err != nil { 6978 var snapshot bytes.Buffer 6979 io.Copy(&snapshot, ringBuffer) 6980 err = &smithy.DeserializationError{ 6981 Err: fmt.Errorf("failed to decode response body, %w", err), 6982 Snapshot: snapshot.Bytes(), 6983 } 6984 return err 6985 } 6986 6987 errorBody.Seek(0, io.SeekStart) 6988 return output 6989} 6990 6991func awsAwsjson11_deserializeErrorServiceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6992 var buff [1024]byte 6993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6994 6995 body := io.TeeReader(errorBody, ringBuffer) 6996 decoder := json.NewDecoder(body) 6997 decoder.UseNumber() 6998 var shape interface{} 6999 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7000 var snapshot bytes.Buffer 7001 io.Copy(&snapshot, ringBuffer) 7002 err = &smithy.DeserializationError{ 7003 Err: fmt.Errorf("failed to decode response body, %w", err), 7004 Snapshot: snapshot.Bytes(), 7005 } 7006 return err 7007 } 7008 7009 output := &types.ServiceNotFoundException{} 7010 err := awsAwsjson11_deserializeDocumentServiceNotFoundException(&output, shape) 7011 7012 if err != nil { 7013 var snapshot bytes.Buffer 7014 io.Copy(&snapshot, ringBuffer) 7015 err = &smithy.DeserializationError{ 7016 Err: fmt.Errorf("failed to decode response body, %w", err), 7017 Snapshot: snapshot.Bytes(), 7018 } 7019 return err 7020 } 7021 7022 errorBody.Seek(0, io.SeekStart) 7023 return output 7024} 7025 7026func awsAwsjson11_deserializeErrorTargetNotConnectedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7027 var buff [1024]byte 7028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7029 7030 body := io.TeeReader(errorBody, ringBuffer) 7031 decoder := json.NewDecoder(body) 7032 decoder.UseNumber() 7033 var shape interface{} 7034 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7035 var snapshot bytes.Buffer 7036 io.Copy(&snapshot, ringBuffer) 7037 err = &smithy.DeserializationError{ 7038 Err: fmt.Errorf("failed to decode response body, %w", err), 7039 Snapshot: snapshot.Bytes(), 7040 } 7041 return err 7042 } 7043 7044 output := &types.TargetNotConnectedException{} 7045 err := awsAwsjson11_deserializeDocumentTargetNotConnectedException(&output, shape) 7046 7047 if err != nil { 7048 var snapshot bytes.Buffer 7049 io.Copy(&snapshot, ringBuffer) 7050 err = &smithy.DeserializationError{ 7051 Err: fmt.Errorf("failed to decode response body, %w", err), 7052 Snapshot: snapshot.Bytes(), 7053 } 7054 return err 7055 } 7056 7057 errorBody.Seek(0, io.SeekStart) 7058 return output 7059} 7060 7061func awsAwsjson11_deserializeErrorTargetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7062 var buff [1024]byte 7063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7064 7065 body := io.TeeReader(errorBody, ringBuffer) 7066 decoder := json.NewDecoder(body) 7067 decoder.UseNumber() 7068 var shape interface{} 7069 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7070 var snapshot bytes.Buffer 7071 io.Copy(&snapshot, ringBuffer) 7072 err = &smithy.DeserializationError{ 7073 Err: fmt.Errorf("failed to decode response body, %w", err), 7074 Snapshot: snapshot.Bytes(), 7075 } 7076 return err 7077 } 7078 7079 output := &types.TargetNotFoundException{} 7080 err := awsAwsjson11_deserializeDocumentTargetNotFoundException(&output, shape) 7081 7082 if err != nil { 7083 var snapshot bytes.Buffer 7084 io.Copy(&snapshot, ringBuffer) 7085 err = &smithy.DeserializationError{ 7086 Err: fmt.Errorf("failed to decode response body, %w", err), 7087 Snapshot: snapshot.Bytes(), 7088 } 7089 return err 7090 } 7091 7092 errorBody.Seek(0, io.SeekStart) 7093 return output 7094} 7095 7096func awsAwsjson11_deserializeErrorTaskSetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7097 var buff [1024]byte 7098 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7099 7100 body := io.TeeReader(errorBody, ringBuffer) 7101 decoder := json.NewDecoder(body) 7102 decoder.UseNumber() 7103 var shape interface{} 7104 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7105 var snapshot bytes.Buffer 7106 io.Copy(&snapshot, ringBuffer) 7107 err = &smithy.DeserializationError{ 7108 Err: fmt.Errorf("failed to decode response body, %w", err), 7109 Snapshot: snapshot.Bytes(), 7110 } 7111 return err 7112 } 7113 7114 output := &types.TaskSetNotFoundException{} 7115 err := awsAwsjson11_deserializeDocumentTaskSetNotFoundException(&output, shape) 7116 7117 if err != nil { 7118 var snapshot bytes.Buffer 7119 io.Copy(&snapshot, ringBuffer) 7120 err = &smithy.DeserializationError{ 7121 Err: fmt.Errorf("failed to decode response body, %w", err), 7122 Snapshot: snapshot.Bytes(), 7123 } 7124 return err 7125 } 7126 7127 errorBody.Seek(0, io.SeekStart) 7128 return output 7129} 7130 7131func awsAwsjson11_deserializeErrorUnsupportedFeatureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7132 var buff [1024]byte 7133 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7134 7135 body := io.TeeReader(errorBody, ringBuffer) 7136 decoder := json.NewDecoder(body) 7137 decoder.UseNumber() 7138 var shape interface{} 7139 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7140 var snapshot bytes.Buffer 7141 io.Copy(&snapshot, ringBuffer) 7142 err = &smithy.DeserializationError{ 7143 Err: fmt.Errorf("failed to decode response body, %w", err), 7144 Snapshot: snapshot.Bytes(), 7145 } 7146 return err 7147 } 7148 7149 output := &types.UnsupportedFeatureException{} 7150 err := awsAwsjson11_deserializeDocumentUnsupportedFeatureException(&output, shape) 7151 7152 if err != nil { 7153 var snapshot bytes.Buffer 7154 io.Copy(&snapshot, ringBuffer) 7155 err = &smithy.DeserializationError{ 7156 Err: fmt.Errorf("failed to decode response body, %w", err), 7157 Snapshot: snapshot.Bytes(), 7158 } 7159 return err 7160 } 7161 7162 errorBody.Seek(0, io.SeekStart) 7163 return output 7164} 7165 7166func awsAwsjson11_deserializeErrorUpdateInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7167 var buff [1024]byte 7168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7169 7170 body := io.TeeReader(errorBody, ringBuffer) 7171 decoder := json.NewDecoder(body) 7172 decoder.UseNumber() 7173 var shape interface{} 7174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7175 var snapshot bytes.Buffer 7176 io.Copy(&snapshot, ringBuffer) 7177 err = &smithy.DeserializationError{ 7178 Err: fmt.Errorf("failed to decode response body, %w", err), 7179 Snapshot: snapshot.Bytes(), 7180 } 7181 return err 7182 } 7183 7184 output := &types.UpdateInProgressException{} 7185 err := awsAwsjson11_deserializeDocumentUpdateInProgressException(&output, shape) 7186 7187 if err != nil { 7188 var snapshot bytes.Buffer 7189 io.Copy(&snapshot, ringBuffer) 7190 err = &smithy.DeserializationError{ 7191 Err: fmt.Errorf("failed to decode response body, %w", err), 7192 Snapshot: snapshot.Bytes(), 7193 } 7194 return err 7195 } 7196 7197 errorBody.Seek(0, io.SeekStart) 7198 return output 7199} 7200 7201func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 7202 if v == nil { 7203 return fmt.Errorf("unexpected nil of type %T", v) 7204 } 7205 if value == nil { 7206 return nil 7207 } 7208 7209 shape, ok := value.(map[string]interface{}) 7210 if !ok { 7211 return fmt.Errorf("unexpected JSON type %v", value) 7212 } 7213 7214 var sv *types.AccessDeniedException 7215 if *v == nil { 7216 sv = &types.AccessDeniedException{} 7217 } else { 7218 sv = *v 7219 } 7220 7221 for key, value := range shape { 7222 switch key { 7223 case "message": 7224 if value != nil { 7225 jtv, ok := value.(string) 7226 if !ok { 7227 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7228 } 7229 sv.Message = ptr.String(jtv) 7230 } 7231 7232 default: 7233 _, _ = key, value 7234 7235 } 7236 } 7237 *v = sv 7238 return nil 7239} 7240 7241func awsAwsjson11_deserializeDocumentAttachment(v **types.Attachment, value interface{}) error { 7242 if v == nil { 7243 return fmt.Errorf("unexpected nil of type %T", v) 7244 } 7245 if value == nil { 7246 return nil 7247 } 7248 7249 shape, ok := value.(map[string]interface{}) 7250 if !ok { 7251 return fmt.Errorf("unexpected JSON type %v", value) 7252 } 7253 7254 var sv *types.Attachment 7255 if *v == nil { 7256 sv = &types.Attachment{} 7257 } else { 7258 sv = *v 7259 } 7260 7261 for key, value := range shape { 7262 switch key { 7263 case "details": 7264 if err := awsAwsjson11_deserializeDocumentAttachmentDetails(&sv.Details, value); err != nil { 7265 return err 7266 } 7267 7268 case "id": 7269 if value != nil { 7270 jtv, ok := value.(string) 7271 if !ok { 7272 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7273 } 7274 sv.Id = ptr.String(jtv) 7275 } 7276 7277 case "status": 7278 if value != nil { 7279 jtv, ok := value.(string) 7280 if !ok { 7281 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7282 } 7283 sv.Status = ptr.String(jtv) 7284 } 7285 7286 case "type": 7287 if value != nil { 7288 jtv, ok := value.(string) 7289 if !ok { 7290 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7291 } 7292 sv.Type = ptr.String(jtv) 7293 } 7294 7295 default: 7296 _, _ = key, value 7297 7298 } 7299 } 7300 *v = sv 7301 return nil 7302} 7303 7304func awsAwsjson11_deserializeDocumentAttachmentDetails(v *[]types.KeyValuePair, value interface{}) error { 7305 if v == nil { 7306 return fmt.Errorf("unexpected nil of type %T", v) 7307 } 7308 if value == nil { 7309 return nil 7310 } 7311 7312 shape, ok := value.([]interface{}) 7313 if !ok { 7314 return fmt.Errorf("unexpected JSON type %v", value) 7315 } 7316 7317 var cv []types.KeyValuePair 7318 if *v == nil { 7319 cv = []types.KeyValuePair{} 7320 } else { 7321 cv = *v 7322 } 7323 7324 for _, value := range shape { 7325 var col types.KeyValuePair 7326 destAddr := &col 7327 if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 7328 return err 7329 } 7330 col = *destAddr 7331 cv = append(cv, col) 7332 7333 } 7334 *v = cv 7335 return nil 7336} 7337 7338func awsAwsjson11_deserializeDocumentAttachments(v *[]types.Attachment, value interface{}) error { 7339 if v == nil { 7340 return fmt.Errorf("unexpected nil of type %T", v) 7341 } 7342 if value == nil { 7343 return nil 7344 } 7345 7346 shape, ok := value.([]interface{}) 7347 if !ok { 7348 return fmt.Errorf("unexpected JSON type %v", value) 7349 } 7350 7351 var cv []types.Attachment 7352 if *v == nil { 7353 cv = []types.Attachment{} 7354 } else { 7355 cv = *v 7356 } 7357 7358 for _, value := range shape { 7359 var col types.Attachment 7360 destAddr := &col 7361 if err := awsAwsjson11_deserializeDocumentAttachment(&destAddr, value); err != nil { 7362 return err 7363 } 7364 col = *destAddr 7365 cv = append(cv, col) 7366 7367 } 7368 *v = cv 7369 return nil 7370} 7371 7372func awsAwsjson11_deserializeDocumentAttribute(v **types.Attribute, value interface{}) error { 7373 if v == nil { 7374 return fmt.Errorf("unexpected nil of type %T", v) 7375 } 7376 if value == nil { 7377 return nil 7378 } 7379 7380 shape, ok := value.(map[string]interface{}) 7381 if !ok { 7382 return fmt.Errorf("unexpected JSON type %v", value) 7383 } 7384 7385 var sv *types.Attribute 7386 if *v == nil { 7387 sv = &types.Attribute{} 7388 } else { 7389 sv = *v 7390 } 7391 7392 for key, value := range shape { 7393 switch key { 7394 case "name": 7395 if value != nil { 7396 jtv, ok := value.(string) 7397 if !ok { 7398 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7399 } 7400 sv.Name = ptr.String(jtv) 7401 } 7402 7403 case "targetId": 7404 if value != nil { 7405 jtv, ok := value.(string) 7406 if !ok { 7407 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7408 } 7409 sv.TargetId = ptr.String(jtv) 7410 } 7411 7412 case "targetType": 7413 if value != nil { 7414 jtv, ok := value.(string) 7415 if !ok { 7416 return fmt.Errorf("expected TargetType to be of type string, got %T instead", value) 7417 } 7418 sv.TargetType = types.TargetType(jtv) 7419 } 7420 7421 case "value": 7422 if value != nil { 7423 jtv, ok := value.(string) 7424 if !ok { 7425 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7426 } 7427 sv.Value = ptr.String(jtv) 7428 } 7429 7430 default: 7431 _, _ = key, value 7432 7433 } 7434 } 7435 *v = sv 7436 return nil 7437} 7438 7439func awsAwsjson11_deserializeDocumentAttributeLimitExceededException(v **types.AttributeLimitExceededException, value interface{}) error { 7440 if v == nil { 7441 return fmt.Errorf("unexpected nil of type %T", v) 7442 } 7443 if value == nil { 7444 return nil 7445 } 7446 7447 shape, ok := value.(map[string]interface{}) 7448 if !ok { 7449 return fmt.Errorf("unexpected JSON type %v", value) 7450 } 7451 7452 var sv *types.AttributeLimitExceededException 7453 if *v == nil { 7454 sv = &types.AttributeLimitExceededException{} 7455 } else { 7456 sv = *v 7457 } 7458 7459 for key, value := range shape { 7460 switch key { 7461 case "message": 7462 if value != nil { 7463 jtv, ok := value.(string) 7464 if !ok { 7465 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7466 } 7467 sv.Message = ptr.String(jtv) 7468 } 7469 7470 default: 7471 _, _ = key, value 7472 7473 } 7474 } 7475 *v = sv 7476 return nil 7477} 7478 7479func awsAwsjson11_deserializeDocumentAttributes(v *[]types.Attribute, value interface{}) error { 7480 if v == nil { 7481 return fmt.Errorf("unexpected nil of type %T", v) 7482 } 7483 if value == nil { 7484 return nil 7485 } 7486 7487 shape, ok := value.([]interface{}) 7488 if !ok { 7489 return fmt.Errorf("unexpected JSON type %v", value) 7490 } 7491 7492 var cv []types.Attribute 7493 if *v == nil { 7494 cv = []types.Attribute{} 7495 } else { 7496 cv = *v 7497 } 7498 7499 for _, value := range shape { 7500 var col types.Attribute 7501 destAddr := &col 7502 if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil { 7503 return err 7504 } 7505 col = *destAddr 7506 cv = append(cv, col) 7507 7508 } 7509 *v = cv 7510 return nil 7511} 7512 7513func awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(v **types.AutoScalingGroupProvider, value interface{}) error { 7514 if v == nil { 7515 return fmt.Errorf("unexpected nil of type %T", v) 7516 } 7517 if value == nil { 7518 return nil 7519 } 7520 7521 shape, ok := value.(map[string]interface{}) 7522 if !ok { 7523 return fmt.Errorf("unexpected JSON type %v", value) 7524 } 7525 7526 var sv *types.AutoScalingGroupProvider 7527 if *v == nil { 7528 sv = &types.AutoScalingGroupProvider{} 7529 } else { 7530 sv = *v 7531 } 7532 7533 for key, value := range shape { 7534 switch key { 7535 case "autoScalingGroupArn": 7536 if value != nil { 7537 jtv, ok := value.(string) 7538 if !ok { 7539 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7540 } 7541 sv.AutoScalingGroupArn = ptr.String(jtv) 7542 } 7543 7544 case "managedScaling": 7545 if err := awsAwsjson11_deserializeDocumentManagedScaling(&sv.ManagedScaling, value); err != nil { 7546 return err 7547 } 7548 7549 case "managedTerminationProtection": 7550 if value != nil { 7551 jtv, ok := value.(string) 7552 if !ok { 7553 return fmt.Errorf("expected ManagedTerminationProtection to be of type string, got %T instead", value) 7554 } 7555 sv.ManagedTerminationProtection = types.ManagedTerminationProtection(jtv) 7556 } 7557 7558 default: 7559 _, _ = key, value 7560 7561 } 7562 } 7563 *v = sv 7564 return nil 7565} 7566 7567func awsAwsjson11_deserializeDocumentAwsVpcConfiguration(v **types.AwsVpcConfiguration, value interface{}) error { 7568 if v == nil { 7569 return fmt.Errorf("unexpected nil of type %T", v) 7570 } 7571 if value == nil { 7572 return nil 7573 } 7574 7575 shape, ok := value.(map[string]interface{}) 7576 if !ok { 7577 return fmt.Errorf("unexpected JSON type %v", value) 7578 } 7579 7580 var sv *types.AwsVpcConfiguration 7581 if *v == nil { 7582 sv = &types.AwsVpcConfiguration{} 7583 } else { 7584 sv = *v 7585 } 7586 7587 for key, value := range shape { 7588 switch key { 7589 case "assignPublicIp": 7590 if value != nil { 7591 jtv, ok := value.(string) 7592 if !ok { 7593 return fmt.Errorf("expected AssignPublicIp to be of type string, got %T instead", value) 7594 } 7595 sv.AssignPublicIp = types.AssignPublicIp(jtv) 7596 } 7597 7598 case "securityGroups": 7599 if err := awsAwsjson11_deserializeDocumentStringList(&sv.SecurityGroups, value); err != nil { 7600 return err 7601 } 7602 7603 case "subnets": 7604 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Subnets, value); err != nil { 7605 return err 7606 } 7607 7608 default: 7609 _, _ = key, value 7610 7611 } 7612 } 7613 *v = sv 7614 return nil 7615} 7616 7617func awsAwsjson11_deserializeDocumentBlockedException(v **types.BlockedException, value interface{}) error { 7618 if v == nil { 7619 return fmt.Errorf("unexpected nil of type %T", v) 7620 } 7621 if value == nil { 7622 return nil 7623 } 7624 7625 shape, ok := value.(map[string]interface{}) 7626 if !ok { 7627 return fmt.Errorf("unexpected JSON type %v", value) 7628 } 7629 7630 var sv *types.BlockedException 7631 if *v == nil { 7632 sv = &types.BlockedException{} 7633 } else { 7634 sv = *v 7635 } 7636 7637 for key, value := range shape { 7638 switch key { 7639 case "message": 7640 if value != nil { 7641 jtv, ok := value.(string) 7642 if !ok { 7643 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7644 } 7645 sv.Message = ptr.String(jtv) 7646 } 7647 7648 default: 7649 _, _ = key, value 7650 7651 } 7652 } 7653 *v = sv 7654 return nil 7655} 7656 7657func awsAwsjson11_deserializeDocumentCapacityProvider(v **types.CapacityProvider, value interface{}) error { 7658 if v == nil { 7659 return fmt.Errorf("unexpected nil of type %T", v) 7660 } 7661 if value == nil { 7662 return nil 7663 } 7664 7665 shape, ok := value.(map[string]interface{}) 7666 if !ok { 7667 return fmt.Errorf("unexpected JSON type %v", value) 7668 } 7669 7670 var sv *types.CapacityProvider 7671 if *v == nil { 7672 sv = &types.CapacityProvider{} 7673 } else { 7674 sv = *v 7675 } 7676 7677 for key, value := range shape { 7678 switch key { 7679 case "autoScalingGroupProvider": 7680 if err := awsAwsjson11_deserializeDocumentAutoScalingGroupProvider(&sv.AutoScalingGroupProvider, value); err != nil { 7681 return err 7682 } 7683 7684 case "capacityProviderArn": 7685 if value != nil { 7686 jtv, ok := value.(string) 7687 if !ok { 7688 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7689 } 7690 sv.CapacityProviderArn = ptr.String(jtv) 7691 } 7692 7693 case "name": 7694 if value != nil { 7695 jtv, ok := value.(string) 7696 if !ok { 7697 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7698 } 7699 sv.Name = ptr.String(jtv) 7700 } 7701 7702 case "status": 7703 if value != nil { 7704 jtv, ok := value.(string) 7705 if !ok { 7706 return fmt.Errorf("expected CapacityProviderStatus to be of type string, got %T instead", value) 7707 } 7708 sv.Status = types.CapacityProviderStatus(jtv) 7709 } 7710 7711 case "tags": 7712 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 7713 return err 7714 } 7715 7716 case "updateStatus": 7717 if value != nil { 7718 jtv, ok := value.(string) 7719 if !ok { 7720 return fmt.Errorf("expected CapacityProviderUpdateStatus to be of type string, got %T instead", value) 7721 } 7722 sv.UpdateStatus = types.CapacityProviderUpdateStatus(jtv) 7723 } 7724 7725 case "updateStatusReason": 7726 if value != nil { 7727 jtv, ok := value.(string) 7728 if !ok { 7729 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7730 } 7731 sv.UpdateStatusReason = ptr.String(jtv) 7732 } 7733 7734 default: 7735 _, _ = key, value 7736 7737 } 7738 } 7739 *v = sv 7740 return nil 7741} 7742 7743func awsAwsjson11_deserializeDocumentCapacityProviders(v *[]types.CapacityProvider, value interface{}) error { 7744 if v == nil { 7745 return fmt.Errorf("unexpected nil of type %T", v) 7746 } 7747 if value == nil { 7748 return nil 7749 } 7750 7751 shape, ok := value.([]interface{}) 7752 if !ok { 7753 return fmt.Errorf("unexpected JSON type %v", value) 7754 } 7755 7756 var cv []types.CapacityProvider 7757 if *v == nil { 7758 cv = []types.CapacityProvider{} 7759 } else { 7760 cv = *v 7761 } 7762 7763 for _, value := range shape { 7764 var col types.CapacityProvider 7765 destAddr := &col 7766 if err := awsAwsjson11_deserializeDocumentCapacityProvider(&destAddr, value); err != nil { 7767 return err 7768 } 7769 col = *destAddr 7770 cv = append(cv, col) 7771 7772 } 7773 *v = cv 7774 return nil 7775} 7776 7777func awsAwsjson11_deserializeDocumentCapacityProviderStrategy(v *[]types.CapacityProviderStrategyItem, value interface{}) error { 7778 if v == nil { 7779 return fmt.Errorf("unexpected nil of type %T", v) 7780 } 7781 if value == nil { 7782 return nil 7783 } 7784 7785 shape, ok := value.([]interface{}) 7786 if !ok { 7787 return fmt.Errorf("unexpected JSON type %v", value) 7788 } 7789 7790 var cv []types.CapacityProviderStrategyItem 7791 if *v == nil { 7792 cv = []types.CapacityProviderStrategyItem{} 7793 } else { 7794 cv = *v 7795 } 7796 7797 for _, value := range shape { 7798 var col types.CapacityProviderStrategyItem 7799 destAddr := &col 7800 if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(&destAddr, value); err != nil { 7801 return err 7802 } 7803 col = *destAddr 7804 cv = append(cv, col) 7805 7806 } 7807 *v = cv 7808 return nil 7809} 7810 7811func awsAwsjson11_deserializeDocumentCapacityProviderStrategyItem(v **types.CapacityProviderStrategyItem, value interface{}) error { 7812 if v == nil { 7813 return fmt.Errorf("unexpected nil of type %T", v) 7814 } 7815 if value == nil { 7816 return nil 7817 } 7818 7819 shape, ok := value.(map[string]interface{}) 7820 if !ok { 7821 return fmt.Errorf("unexpected JSON type %v", value) 7822 } 7823 7824 var sv *types.CapacityProviderStrategyItem 7825 if *v == nil { 7826 sv = &types.CapacityProviderStrategyItem{} 7827 } else { 7828 sv = *v 7829 } 7830 7831 for key, value := range shape { 7832 switch key { 7833 case "base": 7834 if value != nil { 7835 jtv, ok := value.(json.Number) 7836 if !ok { 7837 return fmt.Errorf("expected CapacityProviderStrategyItemBase to be json.Number, got %T instead", value) 7838 } 7839 i64, err := jtv.Int64() 7840 if err != nil { 7841 return err 7842 } 7843 sv.Base = int32(i64) 7844 } 7845 7846 case "capacityProvider": 7847 if value != nil { 7848 jtv, ok := value.(string) 7849 if !ok { 7850 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7851 } 7852 sv.CapacityProvider = ptr.String(jtv) 7853 } 7854 7855 case "weight": 7856 if value != nil { 7857 jtv, ok := value.(json.Number) 7858 if !ok { 7859 return fmt.Errorf("expected CapacityProviderStrategyItemWeight to be json.Number, got %T instead", value) 7860 } 7861 i64, err := jtv.Int64() 7862 if err != nil { 7863 return err 7864 } 7865 sv.Weight = int32(i64) 7866 } 7867 7868 default: 7869 _, _ = key, value 7870 7871 } 7872 } 7873 *v = sv 7874 return nil 7875} 7876 7877func awsAwsjson11_deserializeDocumentClientException(v **types.ClientException, value interface{}) error { 7878 if v == nil { 7879 return fmt.Errorf("unexpected nil of type %T", v) 7880 } 7881 if value == nil { 7882 return nil 7883 } 7884 7885 shape, ok := value.(map[string]interface{}) 7886 if !ok { 7887 return fmt.Errorf("unexpected JSON type %v", value) 7888 } 7889 7890 var sv *types.ClientException 7891 if *v == nil { 7892 sv = &types.ClientException{} 7893 } else { 7894 sv = *v 7895 } 7896 7897 for key, value := range shape { 7898 switch key { 7899 case "message": 7900 if value != nil { 7901 jtv, ok := value.(string) 7902 if !ok { 7903 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7904 } 7905 sv.Message = ptr.String(jtv) 7906 } 7907 7908 default: 7909 _, _ = key, value 7910 7911 } 7912 } 7913 *v = sv 7914 return nil 7915} 7916 7917func awsAwsjson11_deserializeDocumentCluster(v **types.Cluster, value interface{}) error { 7918 if v == nil { 7919 return fmt.Errorf("unexpected nil of type %T", v) 7920 } 7921 if value == nil { 7922 return nil 7923 } 7924 7925 shape, ok := value.(map[string]interface{}) 7926 if !ok { 7927 return fmt.Errorf("unexpected JSON type %v", value) 7928 } 7929 7930 var sv *types.Cluster 7931 if *v == nil { 7932 sv = &types.Cluster{} 7933 } else { 7934 sv = *v 7935 } 7936 7937 for key, value := range shape { 7938 switch key { 7939 case "activeServicesCount": 7940 if value != nil { 7941 jtv, ok := value.(json.Number) 7942 if !ok { 7943 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7944 } 7945 i64, err := jtv.Int64() 7946 if err != nil { 7947 return err 7948 } 7949 sv.ActiveServicesCount = int32(i64) 7950 } 7951 7952 case "attachments": 7953 if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil { 7954 return err 7955 } 7956 7957 case "attachmentsStatus": 7958 if value != nil { 7959 jtv, ok := value.(string) 7960 if !ok { 7961 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7962 } 7963 sv.AttachmentsStatus = ptr.String(jtv) 7964 } 7965 7966 case "capacityProviders": 7967 if err := awsAwsjson11_deserializeDocumentStringList(&sv.CapacityProviders, value); err != nil { 7968 return err 7969 } 7970 7971 case "clusterArn": 7972 if value != nil { 7973 jtv, ok := value.(string) 7974 if !ok { 7975 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7976 } 7977 sv.ClusterArn = ptr.String(jtv) 7978 } 7979 7980 case "clusterName": 7981 if value != nil { 7982 jtv, ok := value.(string) 7983 if !ok { 7984 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7985 } 7986 sv.ClusterName = ptr.String(jtv) 7987 } 7988 7989 case "configuration": 7990 if err := awsAwsjson11_deserializeDocumentClusterConfiguration(&sv.Configuration, value); err != nil { 7991 return err 7992 } 7993 7994 case "defaultCapacityProviderStrategy": 7995 if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.DefaultCapacityProviderStrategy, value); err != nil { 7996 return err 7997 } 7998 7999 case "pendingTasksCount": 8000 if value != nil { 8001 jtv, ok := value.(json.Number) 8002 if !ok { 8003 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8004 } 8005 i64, err := jtv.Int64() 8006 if err != nil { 8007 return err 8008 } 8009 sv.PendingTasksCount = int32(i64) 8010 } 8011 8012 case "registeredContainerInstancesCount": 8013 if value != nil { 8014 jtv, ok := value.(json.Number) 8015 if !ok { 8016 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8017 } 8018 i64, err := jtv.Int64() 8019 if err != nil { 8020 return err 8021 } 8022 sv.RegisteredContainerInstancesCount = int32(i64) 8023 } 8024 8025 case "runningTasksCount": 8026 if value != nil { 8027 jtv, ok := value.(json.Number) 8028 if !ok { 8029 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8030 } 8031 i64, err := jtv.Int64() 8032 if err != nil { 8033 return err 8034 } 8035 sv.RunningTasksCount = int32(i64) 8036 } 8037 8038 case "settings": 8039 if err := awsAwsjson11_deserializeDocumentClusterSettings(&sv.Settings, value); err != nil { 8040 return err 8041 } 8042 8043 case "statistics": 8044 if err := awsAwsjson11_deserializeDocumentStatistics(&sv.Statistics, value); err != nil { 8045 return err 8046 } 8047 8048 case "status": 8049 if value != nil { 8050 jtv, ok := value.(string) 8051 if !ok { 8052 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8053 } 8054 sv.Status = ptr.String(jtv) 8055 } 8056 8057 case "tags": 8058 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 8059 return err 8060 } 8061 8062 default: 8063 _, _ = key, value 8064 8065 } 8066 } 8067 *v = sv 8068 return nil 8069} 8070 8071func awsAwsjson11_deserializeDocumentClusterConfiguration(v **types.ClusterConfiguration, value interface{}) error { 8072 if v == nil { 8073 return fmt.Errorf("unexpected nil of type %T", v) 8074 } 8075 if value == nil { 8076 return nil 8077 } 8078 8079 shape, ok := value.(map[string]interface{}) 8080 if !ok { 8081 return fmt.Errorf("unexpected JSON type %v", value) 8082 } 8083 8084 var sv *types.ClusterConfiguration 8085 if *v == nil { 8086 sv = &types.ClusterConfiguration{} 8087 } else { 8088 sv = *v 8089 } 8090 8091 for key, value := range shape { 8092 switch key { 8093 case "executeCommandConfiguration": 8094 if err := awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(&sv.ExecuteCommandConfiguration, value); err != nil { 8095 return err 8096 } 8097 8098 default: 8099 _, _ = key, value 8100 8101 } 8102 } 8103 *v = sv 8104 return nil 8105} 8106 8107func awsAwsjson11_deserializeDocumentClusterContainsContainerInstancesException(v **types.ClusterContainsContainerInstancesException, 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.(map[string]interface{}) 8116 if !ok { 8117 return fmt.Errorf("unexpected JSON type %v", value) 8118 } 8119 8120 var sv *types.ClusterContainsContainerInstancesException 8121 if *v == nil { 8122 sv = &types.ClusterContainsContainerInstancesException{} 8123 } else { 8124 sv = *v 8125 } 8126 8127 for key, value := range shape { 8128 switch key { 8129 case "message": 8130 if value != nil { 8131 jtv, ok := value.(string) 8132 if !ok { 8133 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8134 } 8135 sv.Message = ptr.String(jtv) 8136 } 8137 8138 default: 8139 _, _ = key, value 8140 8141 } 8142 } 8143 *v = sv 8144 return nil 8145} 8146 8147func awsAwsjson11_deserializeDocumentClusterContainsServicesException(v **types.ClusterContainsServicesException, value interface{}) error { 8148 if v == nil { 8149 return fmt.Errorf("unexpected nil of type %T", v) 8150 } 8151 if value == nil { 8152 return nil 8153 } 8154 8155 shape, ok := value.(map[string]interface{}) 8156 if !ok { 8157 return fmt.Errorf("unexpected JSON type %v", value) 8158 } 8159 8160 var sv *types.ClusterContainsServicesException 8161 if *v == nil { 8162 sv = &types.ClusterContainsServicesException{} 8163 } else { 8164 sv = *v 8165 } 8166 8167 for key, value := range shape { 8168 switch key { 8169 case "message": 8170 if value != nil { 8171 jtv, ok := value.(string) 8172 if !ok { 8173 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8174 } 8175 sv.Message = ptr.String(jtv) 8176 } 8177 8178 default: 8179 _, _ = key, value 8180 8181 } 8182 } 8183 *v = sv 8184 return nil 8185} 8186 8187func awsAwsjson11_deserializeDocumentClusterContainsTasksException(v **types.ClusterContainsTasksException, value interface{}) error { 8188 if v == nil { 8189 return fmt.Errorf("unexpected nil of type %T", v) 8190 } 8191 if value == nil { 8192 return nil 8193 } 8194 8195 shape, ok := value.(map[string]interface{}) 8196 if !ok { 8197 return fmt.Errorf("unexpected JSON type %v", value) 8198 } 8199 8200 var sv *types.ClusterContainsTasksException 8201 if *v == nil { 8202 sv = &types.ClusterContainsTasksException{} 8203 } else { 8204 sv = *v 8205 } 8206 8207 for key, value := range shape { 8208 switch key { 8209 case "message": 8210 if value != nil { 8211 jtv, ok := value.(string) 8212 if !ok { 8213 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8214 } 8215 sv.Message = ptr.String(jtv) 8216 } 8217 8218 default: 8219 _, _ = key, value 8220 8221 } 8222 } 8223 *v = sv 8224 return nil 8225} 8226 8227func awsAwsjson11_deserializeDocumentClusterNotFoundException(v **types.ClusterNotFoundException, value interface{}) error { 8228 if v == nil { 8229 return fmt.Errorf("unexpected nil of type %T", v) 8230 } 8231 if value == nil { 8232 return nil 8233 } 8234 8235 shape, ok := value.(map[string]interface{}) 8236 if !ok { 8237 return fmt.Errorf("unexpected JSON type %v", value) 8238 } 8239 8240 var sv *types.ClusterNotFoundException 8241 if *v == nil { 8242 sv = &types.ClusterNotFoundException{} 8243 } else { 8244 sv = *v 8245 } 8246 8247 for key, value := range shape { 8248 switch key { 8249 case "message": 8250 if value != nil { 8251 jtv, ok := value.(string) 8252 if !ok { 8253 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8254 } 8255 sv.Message = ptr.String(jtv) 8256 } 8257 8258 default: 8259 _, _ = key, value 8260 8261 } 8262 } 8263 *v = sv 8264 return nil 8265} 8266 8267func awsAwsjson11_deserializeDocumentClusters(v *[]types.Cluster, value interface{}) error { 8268 if v == nil { 8269 return fmt.Errorf("unexpected nil of type %T", v) 8270 } 8271 if value == nil { 8272 return nil 8273 } 8274 8275 shape, ok := value.([]interface{}) 8276 if !ok { 8277 return fmt.Errorf("unexpected JSON type %v", value) 8278 } 8279 8280 var cv []types.Cluster 8281 if *v == nil { 8282 cv = []types.Cluster{} 8283 } else { 8284 cv = *v 8285 } 8286 8287 for _, value := range shape { 8288 var col types.Cluster 8289 destAddr := &col 8290 if err := awsAwsjson11_deserializeDocumentCluster(&destAddr, value); err != nil { 8291 return err 8292 } 8293 col = *destAddr 8294 cv = append(cv, col) 8295 8296 } 8297 *v = cv 8298 return nil 8299} 8300 8301func awsAwsjson11_deserializeDocumentClusterSetting(v **types.ClusterSetting, value interface{}) error { 8302 if v == nil { 8303 return fmt.Errorf("unexpected nil of type %T", v) 8304 } 8305 if value == nil { 8306 return nil 8307 } 8308 8309 shape, ok := value.(map[string]interface{}) 8310 if !ok { 8311 return fmt.Errorf("unexpected JSON type %v", value) 8312 } 8313 8314 var sv *types.ClusterSetting 8315 if *v == nil { 8316 sv = &types.ClusterSetting{} 8317 } else { 8318 sv = *v 8319 } 8320 8321 for key, value := range shape { 8322 switch key { 8323 case "name": 8324 if value != nil { 8325 jtv, ok := value.(string) 8326 if !ok { 8327 return fmt.Errorf("expected ClusterSettingName to be of type string, got %T instead", value) 8328 } 8329 sv.Name = types.ClusterSettingName(jtv) 8330 } 8331 8332 case "value": 8333 if value != nil { 8334 jtv, ok := value.(string) 8335 if !ok { 8336 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8337 } 8338 sv.Value = ptr.String(jtv) 8339 } 8340 8341 default: 8342 _, _ = key, value 8343 8344 } 8345 } 8346 *v = sv 8347 return nil 8348} 8349 8350func awsAwsjson11_deserializeDocumentClusterSettings(v *[]types.ClusterSetting, value interface{}) error { 8351 if v == nil { 8352 return fmt.Errorf("unexpected nil of type %T", v) 8353 } 8354 if value == nil { 8355 return nil 8356 } 8357 8358 shape, ok := value.([]interface{}) 8359 if !ok { 8360 return fmt.Errorf("unexpected JSON type %v", value) 8361 } 8362 8363 var cv []types.ClusterSetting 8364 if *v == nil { 8365 cv = []types.ClusterSetting{} 8366 } else { 8367 cv = *v 8368 } 8369 8370 for _, value := range shape { 8371 var col types.ClusterSetting 8372 destAddr := &col 8373 if err := awsAwsjson11_deserializeDocumentClusterSetting(&destAddr, value); err != nil { 8374 return err 8375 } 8376 col = *destAddr 8377 cv = append(cv, col) 8378 8379 } 8380 *v = cv 8381 return nil 8382} 8383 8384func awsAwsjson11_deserializeDocumentCompatibilityList(v *[]types.Compatibility, value interface{}) error { 8385 if v == nil { 8386 return fmt.Errorf("unexpected nil of type %T", v) 8387 } 8388 if value == nil { 8389 return nil 8390 } 8391 8392 shape, ok := value.([]interface{}) 8393 if !ok { 8394 return fmt.Errorf("unexpected JSON type %v", value) 8395 } 8396 8397 var cv []types.Compatibility 8398 if *v == nil { 8399 cv = []types.Compatibility{} 8400 } else { 8401 cv = *v 8402 } 8403 8404 for _, value := range shape { 8405 var col types.Compatibility 8406 if value != nil { 8407 jtv, ok := value.(string) 8408 if !ok { 8409 return fmt.Errorf("expected Compatibility to be of type string, got %T instead", value) 8410 } 8411 col = types.Compatibility(jtv) 8412 } 8413 cv = append(cv, col) 8414 8415 } 8416 *v = cv 8417 return nil 8418} 8419 8420func awsAwsjson11_deserializeDocumentContainer(v **types.Container, value interface{}) error { 8421 if v == nil { 8422 return fmt.Errorf("unexpected nil of type %T", v) 8423 } 8424 if value == nil { 8425 return nil 8426 } 8427 8428 shape, ok := value.(map[string]interface{}) 8429 if !ok { 8430 return fmt.Errorf("unexpected JSON type %v", value) 8431 } 8432 8433 var sv *types.Container 8434 if *v == nil { 8435 sv = &types.Container{} 8436 } else { 8437 sv = *v 8438 } 8439 8440 for key, value := range shape { 8441 switch key { 8442 case "containerArn": 8443 if value != nil { 8444 jtv, ok := value.(string) 8445 if !ok { 8446 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8447 } 8448 sv.ContainerArn = ptr.String(jtv) 8449 } 8450 8451 case "cpu": 8452 if value != nil { 8453 jtv, ok := value.(string) 8454 if !ok { 8455 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8456 } 8457 sv.Cpu = ptr.String(jtv) 8458 } 8459 8460 case "exitCode": 8461 if value != nil { 8462 jtv, ok := value.(json.Number) 8463 if !ok { 8464 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 8465 } 8466 i64, err := jtv.Int64() 8467 if err != nil { 8468 return err 8469 } 8470 sv.ExitCode = ptr.Int32(int32(i64)) 8471 } 8472 8473 case "gpuIds": 8474 if err := awsAwsjson11_deserializeDocumentGpuIds(&sv.GpuIds, value); err != nil { 8475 return err 8476 } 8477 8478 case "healthStatus": 8479 if value != nil { 8480 jtv, ok := value.(string) 8481 if !ok { 8482 return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value) 8483 } 8484 sv.HealthStatus = types.HealthStatus(jtv) 8485 } 8486 8487 case "image": 8488 if value != nil { 8489 jtv, ok := value.(string) 8490 if !ok { 8491 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8492 } 8493 sv.Image = ptr.String(jtv) 8494 } 8495 8496 case "imageDigest": 8497 if value != nil { 8498 jtv, ok := value.(string) 8499 if !ok { 8500 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8501 } 8502 sv.ImageDigest = ptr.String(jtv) 8503 } 8504 8505 case "lastStatus": 8506 if value != nil { 8507 jtv, ok := value.(string) 8508 if !ok { 8509 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8510 } 8511 sv.LastStatus = ptr.String(jtv) 8512 } 8513 8514 case "managedAgents": 8515 if err := awsAwsjson11_deserializeDocumentManagedAgents(&sv.ManagedAgents, value); err != nil { 8516 return err 8517 } 8518 8519 case "memory": 8520 if value != nil { 8521 jtv, ok := value.(string) 8522 if !ok { 8523 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8524 } 8525 sv.Memory = ptr.String(jtv) 8526 } 8527 8528 case "memoryReservation": 8529 if value != nil { 8530 jtv, ok := value.(string) 8531 if !ok { 8532 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8533 } 8534 sv.MemoryReservation = ptr.String(jtv) 8535 } 8536 8537 case "name": 8538 if value != nil { 8539 jtv, ok := value.(string) 8540 if !ok { 8541 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8542 } 8543 sv.Name = ptr.String(jtv) 8544 } 8545 8546 case "networkBindings": 8547 if err := awsAwsjson11_deserializeDocumentNetworkBindings(&sv.NetworkBindings, value); err != nil { 8548 return err 8549 } 8550 8551 case "networkInterfaces": 8552 if err := awsAwsjson11_deserializeDocumentNetworkInterfaces(&sv.NetworkInterfaces, value); err != nil { 8553 return err 8554 } 8555 8556 case "reason": 8557 if value != nil { 8558 jtv, ok := value.(string) 8559 if !ok { 8560 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8561 } 8562 sv.Reason = ptr.String(jtv) 8563 } 8564 8565 case "runtimeId": 8566 if value != nil { 8567 jtv, ok := value.(string) 8568 if !ok { 8569 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8570 } 8571 sv.RuntimeId = ptr.String(jtv) 8572 } 8573 8574 case "taskArn": 8575 if value != nil { 8576 jtv, ok := value.(string) 8577 if !ok { 8578 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8579 } 8580 sv.TaskArn = ptr.String(jtv) 8581 } 8582 8583 default: 8584 _, _ = key, value 8585 8586 } 8587 } 8588 *v = sv 8589 return nil 8590} 8591 8592func awsAwsjson11_deserializeDocumentContainerDefinition(v **types.ContainerDefinition, value interface{}) error { 8593 if v == nil { 8594 return fmt.Errorf("unexpected nil of type %T", v) 8595 } 8596 if value == nil { 8597 return nil 8598 } 8599 8600 shape, ok := value.(map[string]interface{}) 8601 if !ok { 8602 return fmt.Errorf("unexpected JSON type %v", value) 8603 } 8604 8605 var sv *types.ContainerDefinition 8606 if *v == nil { 8607 sv = &types.ContainerDefinition{} 8608 } else { 8609 sv = *v 8610 } 8611 8612 for key, value := range shape { 8613 switch key { 8614 case "command": 8615 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil { 8616 return err 8617 } 8618 8619 case "cpu": 8620 if value != nil { 8621 jtv, ok := value.(json.Number) 8622 if !ok { 8623 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8624 } 8625 i64, err := jtv.Int64() 8626 if err != nil { 8627 return err 8628 } 8629 sv.Cpu = int32(i64) 8630 } 8631 8632 case "dependsOn": 8633 if err := awsAwsjson11_deserializeDocumentContainerDependencies(&sv.DependsOn, value); err != nil { 8634 return err 8635 } 8636 8637 case "disableNetworking": 8638 if value != nil { 8639 jtv, ok := value.(bool) 8640 if !ok { 8641 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8642 } 8643 sv.DisableNetworking = ptr.Bool(jtv) 8644 } 8645 8646 case "dnsSearchDomains": 8647 if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsSearchDomains, value); err != nil { 8648 return err 8649 } 8650 8651 case "dnsServers": 8652 if err := awsAwsjson11_deserializeDocumentStringList(&sv.DnsServers, value); err != nil { 8653 return err 8654 } 8655 8656 case "dockerLabels": 8657 if err := awsAwsjson11_deserializeDocumentDockerLabelsMap(&sv.DockerLabels, value); err != nil { 8658 return err 8659 } 8660 8661 case "dockerSecurityOptions": 8662 if err := awsAwsjson11_deserializeDocumentStringList(&sv.DockerSecurityOptions, value); err != nil { 8663 return err 8664 } 8665 8666 case "entryPoint": 8667 if err := awsAwsjson11_deserializeDocumentStringList(&sv.EntryPoint, value); err != nil { 8668 return err 8669 } 8670 8671 case "environment": 8672 if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil { 8673 return err 8674 } 8675 8676 case "environmentFiles": 8677 if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil { 8678 return err 8679 } 8680 8681 case "essential": 8682 if value != nil { 8683 jtv, ok := value.(bool) 8684 if !ok { 8685 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8686 } 8687 sv.Essential = ptr.Bool(jtv) 8688 } 8689 8690 case "extraHosts": 8691 if err := awsAwsjson11_deserializeDocumentHostEntryList(&sv.ExtraHosts, value); err != nil { 8692 return err 8693 } 8694 8695 case "firelensConfiguration": 8696 if err := awsAwsjson11_deserializeDocumentFirelensConfiguration(&sv.FirelensConfiguration, value); err != nil { 8697 return err 8698 } 8699 8700 case "healthCheck": 8701 if err := awsAwsjson11_deserializeDocumentHealthCheck(&sv.HealthCheck, value); err != nil { 8702 return err 8703 } 8704 8705 case "hostname": 8706 if value != nil { 8707 jtv, ok := value.(string) 8708 if !ok { 8709 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8710 } 8711 sv.Hostname = ptr.String(jtv) 8712 } 8713 8714 case "image": 8715 if value != nil { 8716 jtv, ok := value.(string) 8717 if !ok { 8718 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8719 } 8720 sv.Image = ptr.String(jtv) 8721 } 8722 8723 case "interactive": 8724 if value != nil { 8725 jtv, ok := value.(bool) 8726 if !ok { 8727 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8728 } 8729 sv.Interactive = ptr.Bool(jtv) 8730 } 8731 8732 case "links": 8733 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Links, value); err != nil { 8734 return err 8735 } 8736 8737 case "linuxParameters": 8738 if err := awsAwsjson11_deserializeDocumentLinuxParameters(&sv.LinuxParameters, value); err != nil { 8739 return err 8740 } 8741 8742 case "logConfiguration": 8743 if err := awsAwsjson11_deserializeDocumentLogConfiguration(&sv.LogConfiguration, value); err != nil { 8744 return err 8745 } 8746 8747 case "memory": 8748 if value != nil { 8749 jtv, ok := value.(json.Number) 8750 if !ok { 8751 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 8752 } 8753 i64, err := jtv.Int64() 8754 if err != nil { 8755 return err 8756 } 8757 sv.Memory = ptr.Int32(int32(i64)) 8758 } 8759 8760 case "memoryReservation": 8761 if value != nil { 8762 jtv, ok := value.(json.Number) 8763 if !ok { 8764 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 8765 } 8766 i64, err := jtv.Int64() 8767 if err != nil { 8768 return err 8769 } 8770 sv.MemoryReservation = ptr.Int32(int32(i64)) 8771 } 8772 8773 case "mountPoints": 8774 if err := awsAwsjson11_deserializeDocumentMountPointList(&sv.MountPoints, value); err != nil { 8775 return err 8776 } 8777 8778 case "name": 8779 if value != nil { 8780 jtv, ok := value.(string) 8781 if !ok { 8782 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8783 } 8784 sv.Name = ptr.String(jtv) 8785 } 8786 8787 case "portMappings": 8788 if err := awsAwsjson11_deserializeDocumentPortMappingList(&sv.PortMappings, value); err != nil { 8789 return err 8790 } 8791 8792 case "privileged": 8793 if value != nil { 8794 jtv, ok := value.(bool) 8795 if !ok { 8796 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8797 } 8798 sv.Privileged = ptr.Bool(jtv) 8799 } 8800 8801 case "pseudoTerminal": 8802 if value != nil { 8803 jtv, ok := value.(bool) 8804 if !ok { 8805 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8806 } 8807 sv.PseudoTerminal = ptr.Bool(jtv) 8808 } 8809 8810 case "readonlyRootFilesystem": 8811 if value != nil { 8812 jtv, ok := value.(bool) 8813 if !ok { 8814 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 8815 } 8816 sv.ReadonlyRootFilesystem = ptr.Bool(jtv) 8817 } 8818 8819 case "repositoryCredentials": 8820 if err := awsAwsjson11_deserializeDocumentRepositoryCredentials(&sv.RepositoryCredentials, value); err != nil { 8821 return err 8822 } 8823 8824 case "resourceRequirements": 8825 if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil { 8826 return err 8827 } 8828 8829 case "secrets": 8830 if err := awsAwsjson11_deserializeDocumentSecretList(&sv.Secrets, value); err != nil { 8831 return err 8832 } 8833 8834 case "startTimeout": 8835 if value != nil { 8836 jtv, ok := value.(json.Number) 8837 if !ok { 8838 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 8839 } 8840 i64, err := jtv.Int64() 8841 if err != nil { 8842 return err 8843 } 8844 sv.StartTimeout = ptr.Int32(int32(i64)) 8845 } 8846 8847 case "stopTimeout": 8848 if value != nil { 8849 jtv, ok := value.(json.Number) 8850 if !ok { 8851 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 8852 } 8853 i64, err := jtv.Int64() 8854 if err != nil { 8855 return err 8856 } 8857 sv.StopTimeout = ptr.Int32(int32(i64)) 8858 } 8859 8860 case "systemControls": 8861 if err := awsAwsjson11_deserializeDocumentSystemControls(&sv.SystemControls, value); err != nil { 8862 return err 8863 } 8864 8865 case "ulimits": 8866 if err := awsAwsjson11_deserializeDocumentUlimitList(&sv.Ulimits, value); err != nil { 8867 return err 8868 } 8869 8870 case "user": 8871 if value != nil { 8872 jtv, ok := value.(string) 8873 if !ok { 8874 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8875 } 8876 sv.User = ptr.String(jtv) 8877 } 8878 8879 case "volumesFrom": 8880 if err := awsAwsjson11_deserializeDocumentVolumeFromList(&sv.VolumesFrom, value); err != nil { 8881 return err 8882 } 8883 8884 case "workingDirectory": 8885 if value != nil { 8886 jtv, ok := value.(string) 8887 if !ok { 8888 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8889 } 8890 sv.WorkingDirectory = ptr.String(jtv) 8891 } 8892 8893 default: 8894 _, _ = key, value 8895 8896 } 8897 } 8898 *v = sv 8899 return nil 8900} 8901 8902func awsAwsjson11_deserializeDocumentContainerDefinitions(v *[]types.ContainerDefinition, value interface{}) error { 8903 if v == nil { 8904 return fmt.Errorf("unexpected nil of type %T", v) 8905 } 8906 if value == nil { 8907 return nil 8908 } 8909 8910 shape, ok := value.([]interface{}) 8911 if !ok { 8912 return fmt.Errorf("unexpected JSON type %v", value) 8913 } 8914 8915 var cv []types.ContainerDefinition 8916 if *v == nil { 8917 cv = []types.ContainerDefinition{} 8918 } else { 8919 cv = *v 8920 } 8921 8922 for _, value := range shape { 8923 var col types.ContainerDefinition 8924 destAddr := &col 8925 if err := awsAwsjson11_deserializeDocumentContainerDefinition(&destAddr, value); err != nil { 8926 return err 8927 } 8928 col = *destAddr 8929 cv = append(cv, col) 8930 8931 } 8932 *v = cv 8933 return nil 8934} 8935 8936func awsAwsjson11_deserializeDocumentContainerDependencies(v *[]types.ContainerDependency, value interface{}) error { 8937 if v == nil { 8938 return fmt.Errorf("unexpected nil of type %T", v) 8939 } 8940 if value == nil { 8941 return nil 8942 } 8943 8944 shape, ok := value.([]interface{}) 8945 if !ok { 8946 return fmt.Errorf("unexpected JSON type %v", value) 8947 } 8948 8949 var cv []types.ContainerDependency 8950 if *v == nil { 8951 cv = []types.ContainerDependency{} 8952 } else { 8953 cv = *v 8954 } 8955 8956 for _, value := range shape { 8957 var col types.ContainerDependency 8958 destAddr := &col 8959 if err := awsAwsjson11_deserializeDocumentContainerDependency(&destAddr, value); err != nil { 8960 return err 8961 } 8962 col = *destAddr 8963 cv = append(cv, col) 8964 8965 } 8966 *v = cv 8967 return nil 8968} 8969 8970func awsAwsjson11_deserializeDocumentContainerDependency(v **types.ContainerDependency, value interface{}) error { 8971 if v == nil { 8972 return fmt.Errorf("unexpected nil of type %T", v) 8973 } 8974 if value == nil { 8975 return nil 8976 } 8977 8978 shape, ok := value.(map[string]interface{}) 8979 if !ok { 8980 return fmt.Errorf("unexpected JSON type %v", value) 8981 } 8982 8983 var sv *types.ContainerDependency 8984 if *v == nil { 8985 sv = &types.ContainerDependency{} 8986 } else { 8987 sv = *v 8988 } 8989 8990 for key, value := range shape { 8991 switch key { 8992 case "condition": 8993 if value != nil { 8994 jtv, ok := value.(string) 8995 if !ok { 8996 return fmt.Errorf("expected ContainerCondition to be of type string, got %T instead", value) 8997 } 8998 sv.Condition = types.ContainerCondition(jtv) 8999 } 9000 9001 case "containerName": 9002 if value != nil { 9003 jtv, ok := value.(string) 9004 if !ok { 9005 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9006 } 9007 sv.ContainerName = ptr.String(jtv) 9008 } 9009 9010 default: 9011 _, _ = key, value 9012 9013 } 9014 } 9015 *v = sv 9016 return nil 9017} 9018 9019func awsAwsjson11_deserializeDocumentContainerInstance(v **types.ContainerInstance, value interface{}) error { 9020 if v == nil { 9021 return fmt.Errorf("unexpected nil of type %T", v) 9022 } 9023 if value == nil { 9024 return nil 9025 } 9026 9027 shape, ok := value.(map[string]interface{}) 9028 if !ok { 9029 return fmt.Errorf("unexpected JSON type %v", value) 9030 } 9031 9032 var sv *types.ContainerInstance 9033 if *v == nil { 9034 sv = &types.ContainerInstance{} 9035 } else { 9036 sv = *v 9037 } 9038 9039 for key, value := range shape { 9040 switch key { 9041 case "agentConnected": 9042 if value != nil { 9043 jtv, ok := value.(bool) 9044 if !ok { 9045 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9046 } 9047 sv.AgentConnected = jtv 9048 } 9049 9050 case "agentUpdateStatus": 9051 if value != nil { 9052 jtv, ok := value.(string) 9053 if !ok { 9054 return fmt.Errorf("expected AgentUpdateStatus to be of type string, got %T instead", value) 9055 } 9056 sv.AgentUpdateStatus = types.AgentUpdateStatus(jtv) 9057 } 9058 9059 case "attachments": 9060 if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil { 9061 return err 9062 } 9063 9064 case "attributes": 9065 if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 9066 return err 9067 } 9068 9069 case "capacityProviderName": 9070 if value != nil { 9071 jtv, ok := value.(string) 9072 if !ok { 9073 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9074 } 9075 sv.CapacityProviderName = ptr.String(jtv) 9076 } 9077 9078 case "containerInstanceArn": 9079 if value != nil { 9080 jtv, ok := value.(string) 9081 if !ok { 9082 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9083 } 9084 sv.ContainerInstanceArn = ptr.String(jtv) 9085 } 9086 9087 case "ec2InstanceId": 9088 if value != nil { 9089 jtv, ok := value.(string) 9090 if !ok { 9091 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9092 } 9093 sv.Ec2InstanceId = ptr.String(jtv) 9094 } 9095 9096 case "pendingTasksCount": 9097 if value != nil { 9098 jtv, ok := value.(json.Number) 9099 if !ok { 9100 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9101 } 9102 i64, err := jtv.Int64() 9103 if err != nil { 9104 return err 9105 } 9106 sv.PendingTasksCount = int32(i64) 9107 } 9108 9109 case "registeredAt": 9110 if value != nil { 9111 jtv, ok := value.(json.Number) 9112 if !ok { 9113 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9114 } 9115 f64, err := jtv.Float64() 9116 if err != nil { 9117 return err 9118 } 9119 sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9120 } 9121 9122 case "registeredResources": 9123 if err := awsAwsjson11_deserializeDocumentResources(&sv.RegisteredResources, value); err != nil { 9124 return err 9125 } 9126 9127 case "remainingResources": 9128 if err := awsAwsjson11_deserializeDocumentResources(&sv.RemainingResources, value); err != nil { 9129 return err 9130 } 9131 9132 case "runningTasksCount": 9133 if value != nil { 9134 jtv, ok := value.(json.Number) 9135 if !ok { 9136 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9137 } 9138 i64, err := jtv.Int64() 9139 if err != nil { 9140 return err 9141 } 9142 sv.RunningTasksCount = int32(i64) 9143 } 9144 9145 case "status": 9146 if value != nil { 9147 jtv, ok := value.(string) 9148 if !ok { 9149 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9150 } 9151 sv.Status = ptr.String(jtv) 9152 } 9153 9154 case "statusReason": 9155 if value != nil { 9156 jtv, ok := value.(string) 9157 if !ok { 9158 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9159 } 9160 sv.StatusReason = ptr.String(jtv) 9161 } 9162 9163 case "tags": 9164 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 9165 return err 9166 } 9167 9168 case "version": 9169 if value != nil { 9170 jtv, ok := value.(json.Number) 9171 if !ok { 9172 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 9173 } 9174 i64, err := jtv.Int64() 9175 if err != nil { 9176 return err 9177 } 9178 sv.Version = i64 9179 } 9180 9181 case "versionInfo": 9182 if err := awsAwsjson11_deserializeDocumentVersionInfo(&sv.VersionInfo, value); err != nil { 9183 return err 9184 } 9185 9186 default: 9187 _, _ = key, value 9188 9189 } 9190 } 9191 *v = sv 9192 return nil 9193} 9194 9195func awsAwsjson11_deserializeDocumentContainerInstances(v *[]types.ContainerInstance, value interface{}) error { 9196 if v == nil { 9197 return fmt.Errorf("unexpected nil of type %T", v) 9198 } 9199 if value == nil { 9200 return nil 9201 } 9202 9203 shape, ok := value.([]interface{}) 9204 if !ok { 9205 return fmt.Errorf("unexpected JSON type %v", value) 9206 } 9207 9208 var cv []types.ContainerInstance 9209 if *v == nil { 9210 cv = []types.ContainerInstance{} 9211 } else { 9212 cv = *v 9213 } 9214 9215 for _, value := range shape { 9216 var col types.ContainerInstance 9217 destAddr := &col 9218 if err := awsAwsjson11_deserializeDocumentContainerInstance(&destAddr, value); err != nil { 9219 return err 9220 } 9221 col = *destAddr 9222 cv = append(cv, col) 9223 9224 } 9225 *v = cv 9226 return nil 9227} 9228 9229func awsAwsjson11_deserializeDocumentContainerOverride(v **types.ContainerOverride, value interface{}) error { 9230 if v == nil { 9231 return fmt.Errorf("unexpected nil of type %T", v) 9232 } 9233 if value == nil { 9234 return nil 9235 } 9236 9237 shape, ok := value.(map[string]interface{}) 9238 if !ok { 9239 return fmt.Errorf("unexpected JSON type %v", value) 9240 } 9241 9242 var sv *types.ContainerOverride 9243 if *v == nil { 9244 sv = &types.ContainerOverride{} 9245 } else { 9246 sv = *v 9247 } 9248 9249 for key, value := range shape { 9250 switch key { 9251 case "command": 9252 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil { 9253 return err 9254 } 9255 9256 case "cpu": 9257 if value != nil { 9258 jtv, ok := value.(json.Number) 9259 if !ok { 9260 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 9261 } 9262 i64, err := jtv.Int64() 9263 if err != nil { 9264 return err 9265 } 9266 sv.Cpu = ptr.Int32(int32(i64)) 9267 } 9268 9269 case "environment": 9270 if err := awsAwsjson11_deserializeDocumentEnvironmentVariables(&sv.Environment, value); err != nil { 9271 return err 9272 } 9273 9274 case "environmentFiles": 9275 if err := awsAwsjson11_deserializeDocumentEnvironmentFiles(&sv.EnvironmentFiles, value); err != nil { 9276 return err 9277 } 9278 9279 case "memory": 9280 if value != nil { 9281 jtv, ok := value.(json.Number) 9282 if !ok { 9283 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 9284 } 9285 i64, err := jtv.Int64() 9286 if err != nil { 9287 return err 9288 } 9289 sv.Memory = ptr.Int32(int32(i64)) 9290 } 9291 9292 case "memoryReservation": 9293 if value != nil { 9294 jtv, ok := value.(json.Number) 9295 if !ok { 9296 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 9297 } 9298 i64, err := jtv.Int64() 9299 if err != nil { 9300 return err 9301 } 9302 sv.MemoryReservation = ptr.Int32(int32(i64)) 9303 } 9304 9305 case "name": 9306 if value != nil { 9307 jtv, ok := value.(string) 9308 if !ok { 9309 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9310 } 9311 sv.Name = ptr.String(jtv) 9312 } 9313 9314 case "resourceRequirements": 9315 if err := awsAwsjson11_deserializeDocumentResourceRequirements(&sv.ResourceRequirements, value); err != nil { 9316 return err 9317 } 9318 9319 default: 9320 _, _ = key, value 9321 9322 } 9323 } 9324 *v = sv 9325 return nil 9326} 9327 9328func awsAwsjson11_deserializeDocumentContainerOverrides(v *[]types.ContainerOverride, value interface{}) error { 9329 if v == nil { 9330 return fmt.Errorf("unexpected nil of type %T", v) 9331 } 9332 if value == nil { 9333 return nil 9334 } 9335 9336 shape, ok := value.([]interface{}) 9337 if !ok { 9338 return fmt.Errorf("unexpected JSON type %v", value) 9339 } 9340 9341 var cv []types.ContainerOverride 9342 if *v == nil { 9343 cv = []types.ContainerOverride{} 9344 } else { 9345 cv = *v 9346 } 9347 9348 for _, value := range shape { 9349 var col types.ContainerOverride 9350 destAddr := &col 9351 if err := awsAwsjson11_deserializeDocumentContainerOverride(&destAddr, value); err != nil { 9352 return err 9353 } 9354 col = *destAddr 9355 cv = append(cv, col) 9356 9357 } 9358 *v = cv 9359 return nil 9360} 9361 9362func awsAwsjson11_deserializeDocumentContainers(v *[]types.Container, value interface{}) error { 9363 if v == nil { 9364 return fmt.Errorf("unexpected nil of type %T", v) 9365 } 9366 if value == nil { 9367 return nil 9368 } 9369 9370 shape, ok := value.([]interface{}) 9371 if !ok { 9372 return fmt.Errorf("unexpected JSON type %v", value) 9373 } 9374 9375 var cv []types.Container 9376 if *v == nil { 9377 cv = []types.Container{} 9378 } else { 9379 cv = *v 9380 } 9381 9382 for _, value := range shape { 9383 var col types.Container 9384 destAddr := &col 9385 if err := awsAwsjson11_deserializeDocumentContainer(&destAddr, value); err != nil { 9386 return err 9387 } 9388 col = *destAddr 9389 cv = append(cv, col) 9390 9391 } 9392 *v = cv 9393 return nil 9394} 9395 9396func awsAwsjson11_deserializeDocumentDeployment(v **types.Deployment, value interface{}) error { 9397 if v == nil { 9398 return fmt.Errorf("unexpected nil of type %T", v) 9399 } 9400 if value == nil { 9401 return nil 9402 } 9403 9404 shape, ok := value.(map[string]interface{}) 9405 if !ok { 9406 return fmt.Errorf("unexpected JSON type %v", value) 9407 } 9408 9409 var sv *types.Deployment 9410 if *v == nil { 9411 sv = &types.Deployment{} 9412 } else { 9413 sv = *v 9414 } 9415 9416 for key, value := range shape { 9417 switch key { 9418 case "capacityProviderStrategy": 9419 if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil { 9420 return err 9421 } 9422 9423 case "createdAt": 9424 if value != nil { 9425 jtv, ok := value.(json.Number) 9426 if !ok { 9427 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9428 } 9429 f64, err := jtv.Float64() 9430 if err != nil { 9431 return err 9432 } 9433 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9434 } 9435 9436 case "desiredCount": 9437 if value != nil { 9438 jtv, ok := value.(json.Number) 9439 if !ok { 9440 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9441 } 9442 i64, err := jtv.Int64() 9443 if err != nil { 9444 return err 9445 } 9446 sv.DesiredCount = int32(i64) 9447 } 9448 9449 case "failedTasks": 9450 if value != nil { 9451 jtv, ok := value.(json.Number) 9452 if !ok { 9453 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9454 } 9455 i64, err := jtv.Int64() 9456 if err != nil { 9457 return err 9458 } 9459 sv.FailedTasks = int32(i64) 9460 } 9461 9462 case "id": 9463 if value != nil { 9464 jtv, ok := value.(string) 9465 if !ok { 9466 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9467 } 9468 sv.Id = ptr.String(jtv) 9469 } 9470 9471 case "launchType": 9472 if value != nil { 9473 jtv, ok := value.(string) 9474 if !ok { 9475 return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value) 9476 } 9477 sv.LaunchType = types.LaunchType(jtv) 9478 } 9479 9480 case "networkConfiguration": 9481 if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil { 9482 return err 9483 } 9484 9485 case "pendingCount": 9486 if value != nil { 9487 jtv, ok := value.(json.Number) 9488 if !ok { 9489 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9490 } 9491 i64, err := jtv.Int64() 9492 if err != nil { 9493 return err 9494 } 9495 sv.PendingCount = int32(i64) 9496 } 9497 9498 case "platformVersion": 9499 if value != nil { 9500 jtv, ok := value.(string) 9501 if !ok { 9502 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9503 } 9504 sv.PlatformVersion = ptr.String(jtv) 9505 } 9506 9507 case "rolloutState": 9508 if value != nil { 9509 jtv, ok := value.(string) 9510 if !ok { 9511 return fmt.Errorf("expected DeploymentRolloutState to be of type string, got %T instead", value) 9512 } 9513 sv.RolloutState = types.DeploymentRolloutState(jtv) 9514 } 9515 9516 case "rolloutStateReason": 9517 if value != nil { 9518 jtv, ok := value.(string) 9519 if !ok { 9520 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9521 } 9522 sv.RolloutStateReason = ptr.String(jtv) 9523 } 9524 9525 case "runningCount": 9526 if value != nil { 9527 jtv, ok := value.(json.Number) 9528 if !ok { 9529 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 9530 } 9531 i64, err := jtv.Int64() 9532 if err != nil { 9533 return err 9534 } 9535 sv.RunningCount = int32(i64) 9536 } 9537 9538 case "status": 9539 if value != nil { 9540 jtv, ok := value.(string) 9541 if !ok { 9542 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9543 } 9544 sv.Status = ptr.String(jtv) 9545 } 9546 9547 case "taskDefinition": 9548 if value != nil { 9549 jtv, ok := value.(string) 9550 if !ok { 9551 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9552 } 9553 sv.TaskDefinition = ptr.String(jtv) 9554 } 9555 9556 case "updatedAt": 9557 if value != nil { 9558 jtv, ok := value.(json.Number) 9559 if !ok { 9560 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9561 } 9562 f64, err := jtv.Float64() 9563 if err != nil { 9564 return err 9565 } 9566 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9567 } 9568 9569 default: 9570 _, _ = key, value 9571 9572 } 9573 } 9574 *v = sv 9575 return nil 9576} 9577 9578func awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(v **types.DeploymentCircuitBreaker, value interface{}) error { 9579 if v == nil { 9580 return fmt.Errorf("unexpected nil of type %T", v) 9581 } 9582 if value == nil { 9583 return nil 9584 } 9585 9586 shape, ok := value.(map[string]interface{}) 9587 if !ok { 9588 return fmt.Errorf("unexpected JSON type %v", value) 9589 } 9590 9591 var sv *types.DeploymentCircuitBreaker 9592 if *v == nil { 9593 sv = &types.DeploymentCircuitBreaker{} 9594 } else { 9595 sv = *v 9596 } 9597 9598 for key, value := range shape { 9599 switch key { 9600 case "enable": 9601 if value != nil { 9602 jtv, ok := value.(bool) 9603 if !ok { 9604 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9605 } 9606 sv.Enable = jtv 9607 } 9608 9609 case "rollback": 9610 if value != nil { 9611 jtv, ok := value.(bool) 9612 if !ok { 9613 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9614 } 9615 sv.Rollback = jtv 9616 } 9617 9618 default: 9619 _, _ = key, value 9620 9621 } 9622 } 9623 *v = sv 9624 return nil 9625} 9626 9627func awsAwsjson11_deserializeDocumentDeploymentConfiguration(v **types.DeploymentConfiguration, value interface{}) error { 9628 if v == nil { 9629 return fmt.Errorf("unexpected nil of type %T", v) 9630 } 9631 if value == nil { 9632 return nil 9633 } 9634 9635 shape, ok := value.(map[string]interface{}) 9636 if !ok { 9637 return fmt.Errorf("unexpected JSON type %v", value) 9638 } 9639 9640 var sv *types.DeploymentConfiguration 9641 if *v == nil { 9642 sv = &types.DeploymentConfiguration{} 9643 } else { 9644 sv = *v 9645 } 9646 9647 for key, value := range shape { 9648 switch key { 9649 case "deploymentCircuitBreaker": 9650 if err := awsAwsjson11_deserializeDocumentDeploymentCircuitBreaker(&sv.DeploymentCircuitBreaker, value); err != nil { 9651 return err 9652 } 9653 9654 case "maximumPercent": 9655 if value != nil { 9656 jtv, ok := value.(json.Number) 9657 if !ok { 9658 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 9659 } 9660 i64, err := jtv.Int64() 9661 if err != nil { 9662 return err 9663 } 9664 sv.MaximumPercent = ptr.Int32(int32(i64)) 9665 } 9666 9667 case "minimumHealthyPercent": 9668 if value != nil { 9669 jtv, ok := value.(json.Number) 9670 if !ok { 9671 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 9672 } 9673 i64, err := jtv.Int64() 9674 if err != nil { 9675 return err 9676 } 9677 sv.MinimumHealthyPercent = ptr.Int32(int32(i64)) 9678 } 9679 9680 default: 9681 _, _ = key, value 9682 9683 } 9684 } 9685 *v = sv 9686 return nil 9687} 9688 9689func awsAwsjson11_deserializeDocumentDeploymentController(v **types.DeploymentController, value interface{}) error { 9690 if v == nil { 9691 return fmt.Errorf("unexpected nil of type %T", v) 9692 } 9693 if value == nil { 9694 return nil 9695 } 9696 9697 shape, ok := value.(map[string]interface{}) 9698 if !ok { 9699 return fmt.Errorf("unexpected JSON type %v", value) 9700 } 9701 9702 var sv *types.DeploymentController 9703 if *v == nil { 9704 sv = &types.DeploymentController{} 9705 } else { 9706 sv = *v 9707 } 9708 9709 for key, value := range shape { 9710 switch key { 9711 case "type": 9712 if value != nil { 9713 jtv, ok := value.(string) 9714 if !ok { 9715 return fmt.Errorf("expected DeploymentControllerType to be of type string, got %T instead", value) 9716 } 9717 sv.Type = types.DeploymentControllerType(jtv) 9718 } 9719 9720 default: 9721 _, _ = key, value 9722 9723 } 9724 } 9725 *v = sv 9726 return nil 9727} 9728 9729func awsAwsjson11_deserializeDocumentDeployments(v *[]types.Deployment, value interface{}) error { 9730 if v == nil { 9731 return fmt.Errorf("unexpected nil of type %T", v) 9732 } 9733 if value == nil { 9734 return nil 9735 } 9736 9737 shape, ok := value.([]interface{}) 9738 if !ok { 9739 return fmt.Errorf("unexpected JSON type %v", value) 9740 } 9741 9742 var cv []types.Deployment 9743 if *v == nil { 9744 cv = []types.Deployment{} 9745 } else { 9746 cv = *v 9747 } 9748 9749 for _, value := range shape { 9750 var col types.Deployment 9751 destAddr := &col 9752 if err := awsAwsjson11_deserializeDocumentDeployment(&destAddr, value); err != nil { 9753 return err 9754 } 9755 col = *destAddr 9756 cv = append(cv, col) 9757 9758 } 9759 *v = cv 9760 return nil 9761} 9762 9763func awsAwsjson11_deserializeDocumentDevice(v **types.Device, value interface{}) error { 9764 if v == nil { 9765 return fmt.Errorf("unexpected nil of type %T", v) 9766 } 9767 if value == nil { 9768 return nil 9769 } 9770 9771 shape, ok := value.(map[string]interface{}) 9772 if !ok { 9773 return fmt.Errorf("unexpected JSON type %v", value) 9774 } 9775 9776 var sv *types.Device 9777 if *v == nil { 9778 sv = &types.Device{} 9779 } else { 9780 sv = *v 9781 } 9782 9783 for key, value := range shape { 9784 switch key { 9785 case "containerPath": 9786 if value != nil { 9787 jtv, ok := value.(string) 9788 if !ok { 9789 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9790 } 9791 sv.ContainerPath = ptr.String(jtv) 9792 } 9793 9794 case "hostPath": 9795 if value != nil { 9796 jtv, ok := value.(string) 9797 if !ok { 9798 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9799 } 9800 sv.HostPath = ptr.String(jtv) 9801 } 9802 9803 case "permissions": 9804 if err := awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(&sv.Permissions, value); err != nil { 9805 return err 9806 } 9807 9808 default: 9809 _, _ = key, value 9810 9811 } 9812 } 9813 *v = sv 9814 return nil 9815} 9816 9817func awsAwsjson11_deserializeDocumentDeviceCgroupPermissions(v *[]types.DeviceCgroupPermission, value interface{}) error { 9818 if v == nil { 9819 return fmt.Errorf("unexpected nil of type %T", v) 9820 } 9821 if value == nil { 9822 return nil 9823 } 9824 9825 shape, ok := value.([]interface{}) 9826 if !ok { 9827 return fmt.Errorf("unexpected JSON type %v", value) 9828 } 9829 9830 var cv []types.DeviceCgroupPermission 9831 if *v == nil { 9832 cv = []types.DeviceCgroupPermission{} 9833 } else { 9834 cv = *v 9835 } 9836 9837 for _, value := range shape { 9838 var col types.DeviceCgroupPermission 9839 if value != nil { 9840 jtv, ok := value.(string) 9841 if !ok { 9842 return fmt.Errorf("expected DeviceCgroupPermission to be of type string, got %T instead", value) 9843 } 9844 col = types.DeviceCgroupPermission(jtv) 9845 } 9846 cv = append(cv, col) 9847 9848 } 9849 *v = cv 9850 return nil 9851} 9852 9853func awsAwsjson11_deserializeDocumentDevicesList(v *[]types.Device, value interface{}) error { 9854 if v == nil { 9855 return fmt.Errorf("unexpected nil of type %T", v) 9856 } 9857 if value == nil { 9858 return nil 9859 } 9860 9861 shape, ok := value.([]interface{}) 9862 if !ok { 9863 return fmt.Errorf("unexpected JSON type %v", value) 9864 } 9865 9866 var cv []types.Device 9867 if *v == nil { 9868 cv = []types.Device{} 9869 } else { 9870 cv = *v 9871 } 9872 9873 for _, value := range shape { 9874 var col types.Device 9875 destAddr := &col 9876 if err := awsAwsjson11_deserializeDocumentDevice(&destAddr, value); err != nil { 9877 return err 9878 } 9879 col = *destAddr 9880 cv = append(cv, col) 9881 9882 } 9883 *v = cv 9884 return nil 9885} 9886 9887func awsAwsjson11_deserializeDocumentDockerLabelsMap(v *map[string]string, value interface{}) error { 9888 if v == nil { 9889 return fmt.Errorf("unexpected nil of type %T", v) 9890 } 9891 if value == nil { 9892 return nil 9893 } 9894 9895 shape, ok := value.(map[string]interface{}) 9896 if !ok { 9897 return fmt.Errorf("unexpected JSON type %v", value) 9898 } 9899 9900 var mv map[string]string 9901 if *v == nil { 9902 mv = map[string]string{} 9903 } else { 9904 mv = *v 9905 } 9906 9907 for key, value := range shape { 9908 var parsedVal string 9909 if value != nil { 9910 jtv, ok := value.(string) 9911 if !ok { 9912 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9913 } 9914 parsedVal = jtv 9915 } 9916 mv[key] = parsedVal 9917 9918 } 9919 *v = mv 9920 return nil 9921} 9922 9923func awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(v **types.DockerVolumeConfiguration, value interface{}) error { 9924 if v == nil { 9925 return fmt.Errorf("unexpected nil of type %T", v) 9926 } 9927 if value == nil { 9928 return nil 9929 } 9930 9931 shape, ok := value.(map[string]interface{}) 9932 if !ok { 9933 return fmt.Errorf("unexpected JSON type %v", value) 9934 } 9935 9936 var sv *types.DockerVolumeConfiguration 9937 if *v == nil { 9938 sv = &types.DockerVolumeConfiguration{} 9939 } else { 9940 sv = *v 9941 } 9942 9943 for key, value := range shape { 9944 switch key { 9945 case "autoprovision": 9946 if value != nil { 9947 jtv, ok := value.(bool) 9948 if !ok { 9949 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 9950 } 9951 sv.Autoprovision = ptr.Bool(jtv) 9952 } 9953 9954 case "driver": 9955 if value != nil { 9956 jtv, ok := value.(string) 9957 if !ok { 9958 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9959 } 9960 sv.Driver = ptr.String(jtv) 9961 } 9962 9963 case "driverOpts": 9964 if err := awsAwsjson11_deserializeDocumentStringMap(&sv.DriverOpts, value); err != nil { 9965 return err 9966 } 9967 9968 case "labels": 9969 if err := awsAwsjson11_deserializeDocumentStringMap(&sv.Labels, value); err != nil { 9970 return err 9971 } 9972 9973 case "scope": 9974 if value != nil { 9975 jtv, ok := value.(string) 9976 if !ok { 9977 return fmt.Errorf("expected Scope to be of type string, got %T instead", value) 9978 } 9979 sv.Scope = types.Scope(jtv) 9980 } 9981 9982 default: 9983 _, _ = key, value 9984 9985 } 9986 } 9987 *v = sv 9988 return nil 9989} 9990 9991func awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(v **types.EFSAuthorizationConfig, value interface{}) error { 9992 if v == nil { 9993 return fmt.Errorf("unexpected nil of type %T", v) 9994 } 9995 if value == nil { 9996 return nil 9997 } 9998 9999 shape, ok := value.(map[string]interface{}) 10000 if !ok { 10001 return fmt.Errorf("unexpected JSON type %v", value) 10002 } 10003 10004 var sv *types.EFSAuthorizationConfig 10005 if *v == nil { 10006 sv = &types.EFSAuthorizationConfig{} 10007 } else { 10008 sv = *v 10009 } 10010 10011 for key, value := range shape { 10012 switch key { 10013 case "accessPointId": 10014 if value != nil { 10015 jtv, ok := value.(string) 10016 if !ok { 10017 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10018 } 10019 sv.AccessPointId = ptr.String(jtv) 10020 } 10021 10022 case "iam": 10023 if value != nil { 10024 jtv, ok := value.(string) 10025 if !ok { 10026 return fmt.Errorf("expected EFSAuthorizationConfigIAM to be of type string, got %T instead", value) 10027 } 10028 sv.Iam = types.EFSAuthorizationConfigIAM(jtv) 10029 } 10030 10031 default: 10032 _, _ = key, value 10033 10034 } 10035 } 10036 *v = sv 10037 return nil 10038} 10039 10040func awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(v **types.EFSVolumeConfiguration, value interface{}) error { 10041 if v == nil { 10042 return fmt.Errorf("unexpected nil of type %T", v) 10043 } 10044 if value == nil { 10045 return nil 10046 } 10047 10048 shape, ok := value.(map[string]interface{}) 10049 if !ok { 10050 return fmt.Errorf("unexpected JSON type %v", value) 10051 } 10052 10053 var sv *types.EFSVolumeConfiguration 10054 if *v == nil { 10055 sv = &types.EFSVolumeConfiguration{} 10056 } else { 10057 sv = *v 10058 } 10059 10060 for key, value := range shape { 10061 switch key { 10062 case "authorizationConfig": 10063 if err := awsAwsjson11_deserializeDocumentEFSAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil { 10064 return err 10065 } 10066 10067 case "fileSystemId": 10068 if value != nil { 10069 jtv, ok := value.(string) 10070 if !ok { 10071 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10072 } 10073 sv.FileSystemId = ptr.String(jtv) 10074 } 10075 10076 case "rootDirectory": 10077 if value != nil { 10078 jtv, ok := value.(string) 10079 if !ok { 10080 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10081 } 10082 sv.RootDirectory = ptr.String(jtv) 10083 } 10084 10085 case "transitEncryption": 10086 if value != nil { 10087 jtv, ok := value.(string) 10088 if !ok { 10089 return fmt.Errorf("expected EFSTransitEncryption to be of type string, got %T instead", value) 10090 } 10091 sv.TransitEncryption = types.EFSTransitEncryption(jtv) 10092 } 10093 10094 case "transitEncryptionPort": 10095 if value != nil { 10096 jtv, ok := value.(json.Number) 10097 if !ok { 10098 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 10099 } 10100 i64, err := jtv.Int64() 10101 if err != nil { 10102 return err 10103 } 10104 sv.TransitEncryptionPort = ptr.Int32(int32(i64)) 10105 } 10106 10107 default: 10108 _, _ = key, value 10109 10110 } 10111 } 10112 *v = sv 10113 return nil 10114} 10115 10116func awsAwsjson11_deserializeDocumentEnvironmentFile(v **types.EnvironmentFile, value interface{}) error { 10117 if v == nil { 10118 return fmt.Errorf("unexpected nil of type %T", v) 10119 } 10120 if value == nil { 10121 return nil 10122 } 10123 10124 shape, ok := value.(map[string]interface{}) 10125 if !ok { 10126 return fmt.Errorf("unexpected JSON type %v", value) 10127 } 10128 10129 var sv *types.EnvironmentFile 10130 if *v == nil { 10131 sv = &types.EnvironmentFile{} 10132 } else { 10133 sv = *v 10134 } 10135 10136 for key, value := range shape { 10137 switch key { 10138 case "type": 10139 if value != nil { 10140 jtv, ok := value.(string) 10141 if !ok { 10142 return fmt.Errorf("expected EnvironmentFileType to be of type string, got %T instead", value) 10143 } 10144 sv.Type = types.EnvironmentFileType(jtv) 10145 } 10146 10147 case "value": 10148 if value != nil { 10149 jtv, ok := value.(string) 10150 if !ok { 10151 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10152 } 10153 sv.Value = ptr.String(jtv) 10154 } 10155 10156 default: 10157 _, _ = key, value 10158 10159 } 10160 } 10161 *v = sv 10162 return nil 10163} 10164 10165func awsAwsjson11_deserializeDocumentEnvironmentFiles(v *[]types.EnvironmentFile, value interface{}) error { 10166 if v == nil { 10167 return fmt.Errorf("unexpected nil of type %T", v) 10168 } 10169 if value == nil { 10170 return nil 10171 } 10172 10173 shape, ok := value.([]interface{}) 10174 if !ok { 10175 return fmt.Errorf("unexpected JSON type %v", value) 10176 } 10177 10178 var cv []types.EnvironmentFile 10179 if *v == nil { 10180 cv = []types.EnvironmentFile{} 10181 } else { 10182 cv = *v 10183 } 10184 10185 for _, value := range shape { 10186 var col types.EnvironmentFile 10187 destAddr := &col 10188 if err := awsAwsjson11_deserializeDocumentEnvironmentFile(&destAddr, value); err != nil { 10189 return err 10190 } 10191 col = *destAddr 10192 cv = append(cv, col) 10193 10194 } 10195 *v = cv 10196 return nil 10197} 10198 10199func awsAwsjson11_deserializeDocumentEnvironmentVariables(v *[]types.KeyValuePair, value interface{}) error { 10200 if v == nil { 10201 return fmt.Errorf("unexpected nil of type %T", v) 10202 } 10203 if value == nil { 10204 return nil 10205 } 10206 10207 shape, ok := value.([]interface{}) 10208 if !ok { 10209 return fmt.Errorf("unexpected JSON type %v", value) 10210 } 10211 10212 var cv []types.KeyValuePair 10213 if *v == nil { 10214 cv = []types.KeyValuePair{} 10215 } else { 10216 cv = *v 10217 } 10218 10219 for _, value := range shape { 10220 var col types.KeyValuePair 10221 destAddr := &col 10222 if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 10223 return err 10224 } 10225 col = *destAddr 10226 cv = append(cv, col) 10227 10228 } 10229 *v = cv 10230 return nil 10231} 10232 10233func awsAwsjson11_deserializeDocumentEphemeralStorage(v **types.EphemeralStorage, value interface{}) error { 10234 if v == nil { 10235 return fmt.Errorf("unexpected nil of type %T", v) 10236 } 10237 if value == nil { 10238 return nil 10239 } 10240 10241 shape, ok := value.(map[string]interface{}) 10242 if !ok { 10243 return fmt.Errorf("unexpected JSON type %v", value) 10244 } 10245 10246 var sv *types.EphemeralStorage 10247 if *v == nil { 10248 sv = &types.EphemeralStorage{} 10249 } else { 10250 sv = *v 10251 } 10252 10253 for key, value := range shape { 10254 switch key { 10255 case "sizeInGiB": 10256 if value != nil { 10257 jtv, ok := value.(json.Number) 10258 if !ok { 10259 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 10260 } 10261 i64, err := jtv.Int64() 10262 if err != nil { 10263 return err 10264 } 10265 sv.SizeInGiB = int32(i64) 10266 } 10267 10268 default: 10269 _, _ = key, value 10270 10271 } 10272 } 10273 *v = sv 10274 return nil 10275} 10276 10277func awsAwsjson11_deserializeDocumentExecuteCommandConfiguration(v **types.ExecuteCommandConfiguration, value interface{}) error { 10278 if v == nil { 10279 return fmt.Errorf("unexpected nil of type %T", v) 10280 } 10281 if value == nil { 10282 return nil 10283 } 10284 10285 shape, ok := value.(map[string]interface{}) 10286 if !ok { 10287 return fmt.Errorf("unexpected JSON type %v", value) 10288 } 10289 10290 var sv *types.ExecuteCommandConfiguration 10291 if *v == nil { 10292 sv = &types.ExecuteCommandConfiguration{} 10293 } else { 10294 sv = *v 10295 } 10296 10297 for key, value := range shape { 10298 switch key { 10299 case "kmsKeyId": 10300 if value != nil { 10301 jtv, ok := value.(string) 10302 if !ok { 10303 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10304 } 10305 sv.KmsKeyId = ptr.String(jtv) 10306 } 10307 10308 case "logConfiguration": 10309 if err := awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(&sv.LogConfiguration, value); err != nil { 10310 return err 10311 } 10312 10313 case "logging": 10314 if value != nil { 10315 jtv, ok := value.(string) 10316 if !ok { 10317 return fmt.Errorf("expected ExecuteCommandLogging to be of type string, got %T instead", value) 10318 } 10319 sv.Logging = types.ExecuteCommandLogging(jtv) 10320 } 10321 10322 default: 10323 _, _ = key, value 10324 10325 } 10326 } 10327 *v = sv 10328 return nil 10329} 10330 10331func awsAwsjson11_deserializeDocumentExecuteCommandLogConfiguration(v **types.ExecuteCommandLogConfiguration, value interface{}) error { 10332 if v == nil { 10333 return fmt.Errorf("unexpected nil of type %T", v) 10334 } 10335 if value == nil { 10336 return nil 10337 } 10338 10339 shape, ok := value.(map[string]interface{}) 10340 if !ok { 10341 return fmt.Errorf("unexpected JSON type %v", value) 10342 } 10343 10344 var sv *types.ExecuteCommandLogConfiguration 10345 if *v == nil { 10346 sv = &types.ExecuteCommandLogConfiguration{} 10347 } else { 10348 sv = *v 10349 } 10350 10351 for key, value := range shape { 10352 switch key { 10353 case "cloudWatchEncryptionEnabled": 10354 if value != nil { 10355 jtv, ok := value.(bool) 10356 if !ok { 10357 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 10358 } 10359 sv.CloudWatchEncryptionEnabled = jtv 10360 } 10361 10362 case "cloudWatchLogGroupName": 10363 if value != nil { 10364 jtv, ok := value.(string) 10365 if !ok { 10366 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10367 } 10368 sv.CloudWatchLogGroupName = ptr.String(jtv) 10369 } 10370 10371 case "s3BucketName": 10372 if value != nil { 10373 jtv, ok := value.(string) 10374 if !ok { 10375 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10376 } 10377 sv.S3BucketName = ptr.String(jtv) 10378 } 10379 10380 case "s3EncryptionEnabled": 10381 if value != nil { 10382 jtv, ok := value.(bool) 10383 if !ok { 10384 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 10385 } 10386 sv.S3EncryptionEnabled = jtv 10387 } 10388 10389 case "s3KeyPrefix": 10390 if value != nil { 10391 jtv, ok := value.(string) 10392 if !ok { 10393 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10394 } 10395 sv.S3KeyPrefix = ptr.String(jtv) 10396 } 10397 10398 default: 10399 _, _ = key, value 10400 10401 } 10402 } 10403 *v = sv 10404 return nil 10405} 10406 10407func awsAwsjson11_deserializeDocumentFailure(v **types.Failure, value interface{}) error { 10408 if v == nil { 10409 return fmt.Errorf("unexpected nil of type %T", v) 10410 } 10411 if value == nil { 10412 return nil 10413 } 10414 10415 shape, ok := value.(map[string]interface{}) 10416 if !ok { 10417 return fmt.Errorf("unexpected JSON type %v", value) 10418 } 10419 10420 var sv *types.Failure 10421 if *v == nil { 10422 sv = &types.Failure{} 10423 } else { 10424 sv = *v 10425 } 10426 10427 for key, value := range shape { 10428 switch key { 10429 case "arn": 10430 if value != nil { 10431 jtv, ok := value.(string) 10432 if !ok { 10433 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10434 } 10435 sv.Arn = ptr.String(jtv) 10436 } 10437 10438 case "detail": 10439 if value != nil { 10440 jtv, ok := value.(string) 10441 if !ok { 10442 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10443 } 10444 sv.Detail = ptr.String(jtv) 10445 } 10446 10447 case "reason": 10448 if value != nil { 10449 jtv, ok := value.(string) 10450 if !ok { 10451 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10452 } 10453 sv.Reason = ptr.String(jtv) 10454 } 10455 10456 default: 10457 _, _ = key, value 10458 10459 } 10460 } 10461 *v = sv 10462 return nil 10463} 10464 10465func awsAwsjson11_deserializeDocumentFailures(v *[]types.Failure, 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.Failure 10479 if *v == nil { 10480 cv = []types.Failure{} 10481 } else { 10482 cv = *v 10483 } 10484 10485 for _, value := range shape { 10486 var col types.Failure 10487 destAddr := &col 10488 if err := awsAwsjson11_deserializeDocumentFailure(&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_deserializeDocumentFirelensConfiguration(v **types.FirelensConfiguration, 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.FirelensConfiguration 10513 if *v == nil { 10514 sv = &types.FirelensConfiguration{} 10515 } else { 10516 sv = *v 10517 } 10518 10519 for key, value := range shape { 10520 switch key { 10521 case "options": 10522 if err := awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(&sv.Options, value); err != nil { 10523 return err 10524 } 10525 10526 case "type": 10527 if value != nil { 10528 jtv, ok := value.(string) 10529 if !ok { 10530 return fmt.Errorf("expected FirelensConfigurationType to be of type string, got %T instead", value) 10531 } 10532 sv.Type = types.FirelensConfigurationType(jtv) 10533 } 10534 10535 default: 10536 _, _ = key, value 10537 10538 } 10539 } 10540 *v = sv 10541 return nil 10542} 10543 10544func awsAwsjson11_deserializeDocumentFirelensConfigurationOptionsMap(v *map[string]string, value interface{}) error { 10545 if v == nil { 10546 return fmt.Errorf("unexpected nil of type %T", v) 10547 } 10548 if value == nil { 10549 return nil 10550 } 10551 10552 shape, ok := value.(map[string]interface{}) 10553 if !ok { 10554 return fmt.Errorf("unexpected JSON type %v", value) 10555 } 10556 10557 var mv map[string]string 10558 if *v == nil { 10559 mv = map[string]string{} 10560 } else { 10561 mv = *v 10562 } 10563 10564 for key, value := range shape { 10565 var parsedVal string 10566 if value != nil { 10567 jtv, ok := value.(string) 10568 if !ok { 10569 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10570 } 10571 parsedVal = jtv 10572 } 10573 mv[key] = parsedVal 10574 10575 } 10576 *v = mv 10577 return nil 10578} 10579 10580func awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(v **types.FSxWindowsFileServerAuthorizationConfig, value interface{}) error { 10581 if v == nil { 10582 return fmt.Errorf("unexpected nil of type %T", v) 10583 } 10584 if value == nil { 10585 return nil 10586 } 10587 10588 shape, ok := value.(map[string]interface{}) 10589 if !ok { 10590 return fmt.Errorf("unexpected JSON type %v", value) 10591 } 10592 10593 var sv *types.FSxWindowsFileServerAuthorizationConfig 10594 if *v == nil { 10595 sv = &types.FSxWindowsFileServerAuthorizationConfig{} 10596 } else { 10597 sv = *v 10598 } 10599 10600 for key, value := range shape { 10601 switch key { 10602 case "credentialsParameter": 10603 if value != nil { 10604 jtv, ok := value.(string) 10605 if !ok { 10606 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10607 } 10608 sv.CredentialsParameter = ptr.String(jtv) 10609 } 10610 10611 case "domain": 10612 if value != nil { 10613 jtv, ok := value.(string) 10614 if !ok { 10615 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10616 } 10617 sv.Domain = ptr.String(jtv) 10618 } 10619 10620 default: 10621 _, _ = key, value 10622 10623 } 10624 } 10625 *v = sv 10626 return nil 10627} 10628 10629func awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(v **types.FSxWindowsFileServerVolumeConfiguration, value interface{}) error { 10630 if v == nil { 10631 return fmt.Errorf("unexpected nil of type %T", v) 10632 } 10633 if value == nil { 10634 return nil 10635 } 10636 10637 shape, ok := value.(map[string]interface{}) 10638 if !ok { 10639 return fmt.Errorf("unexpected JSON type %v", value) 10640 } 10641 10642 var sv *types.FSxWindowsFileServerVolumeConfiguration 10643 if *v == nil { 10644 sv = &types.FSxWindowsFileServerVolumeConfiguration{} 10645 } else { 10646 sv = *v 10647 } 10648 10649 for key, value := range shape { 10650 switch key { 10651 case "authorizationConfig": 10652 if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerAuthorizationConfig(&sv.AuthorizationConfig, value); err != nil { 10653 return err 10654 } 10655 10656 case "fileSystemId": 10657 if value != nil { 10658 jtv, ok := value.(string) 10659 if !ok { 10660 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10661 } 10662 sv.FileSystemId = ptr.String(jtv) 10663 } 10664 10665 case "rootDirectory": 10666 if value != nil { 10667 jtv, ok := value.(string) 10668 if !ok { 10669 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10670 } 10671 sv.RootDirectory = ptr.String(jtv) 10672 } 10673 10674 default: 10675 _, _ = key, value 10676 10677 } 10678 } 10679 *v = sv 10680 return nil 10681} 10682 10683func awsAwsjson11_deserializeDocumentGpuIds(v *[]string, value interface{}) error { 10684 if v == nil { 10685 return fmt.Errorf("unexpected nil of type %T", v) 10686 } 10687 if value == nil { 10688 return nil 10689 } 10690 10691 shape, ok := value.([]interface{}) 10692 if !ok { 10693 return fmt.Errorf("unexpected JSON type %v", value) 10694 } 10695 10696 var cv []string 10697 if *v == nil { 10698 cv = []string{} 10699 } else { 10700 cv = *v 10701 } 10702 10703 for _, value := range shape { 10704 var col string 10705 if value != nil { 10706 jtv, ok := value.(string) 10707 if !ok { 10708 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10709 } 10710 col = jtv 10711 } 10712 cv = append(cv, col) 10713 10714 } 10715 *v = cv 10716 return nil 10717} 10718 10719func awsAwsjson11_deserializeDocumentHealthCheck(v **types.HealthCheck, value interface{}) error { 10720 if v == nil { 10721 return fmt.Errorf("unexpected nil of type %T", v) 10722 } 10723 if value == nil { 10724 return nil 10725 } 10726 10727 shape, ok := value.(map[string]interface{}) 10728 if !ok { 10729 return fmt.Errorf("unexpected JSON type %v", value) 10730 } 10731 10732 var sv *types.HealthCheck 10733 if *v == nil { 10734 sv = &types.HealthCheck{} 10735 } else { 10736 sv = *v 10737 } 10738 10739 for key, value := range shape { 10740 switch key { 10741 case "command": 10742 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Command, value); err != nil { 10743 return err 10744 } 10745 10746 case "interval": 10747 if value != nil { 10748 jtv, ok := value.(json.Number) 10749 if !ok { 10750 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 10751 } 10752 i64, err := jtv.Int64() 10753 if err != nil { 10754 return err 10755 } 10756 sv.Interval = ptr.Int32(int32(i64)) 10757 } 10758 10759 case "retries": 10760 if value != nil { 10761 jtv, ok := value.(json.Number) 10762 if !ok { 10763 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 10764 } 10765 i64, err := jtv.Int64() 10766 if err != nil { 10767 return err 10768 } 10769 sv.Retries = ptr.Int32(int32(i64)) 10770 } 10771 10772 case "startPeriod": 10773 if value != nil { 10774 jtv, ok := value.(json.Number) 10775 if !ok { 10776 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 10777 } 10778 i64, err := jtv.Int64() 10779 if err != nil { 10780 return err 10781 } 10782 sv.StartPeriod = ptr.Int32(int32(i64)) 10783 } 10784 10785 case "timeout": 10786 if value != nil { 10787 jtv, ok := value.(json.Number) 10788 if !ok { 10789 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 10790 } 10791 i64, err := jtv.Int64() 10792 if err != nil { 10793 return err 10794 } 10795 sv.Timeout = ptr.Int32(int32(i64)) 10796 } 10797 10798 default: 10799 _, _ = key, value 10800 10801 } 10802 } 10803 *v = sv 10804 return nil 10805} 10806 10807func awsAwsjson11_deserializeDocumentHostEntry(v **types.HostEntry, value interface{}) error { 10808 if v == nil { 10809 return fmt.Errorf("unexpected nil of type %T", v) 10810 } 10811 if value == nil { 10812 return nil 10813 } 10814 10815 shape, ok := value.(map[string]interface{}) 10816 if !ok { 10817 return fmt.Errorf("unexpected JSON type %v", value) 10818 } 10819 10820 var sv *types.HostEntry 10821 if *v == nil { 10822 sv = &types.HostEntry{} 10823 } else { 10824 sv = *v 10825 } 10826 10827 for key, value := range shape { 10828 switch key { 10829 case "hostname": 10830 if value != nil { 10831 jtv, ok := value.(string) 10832 if !ok { 10833 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10834 } 10835 sv.Hostname = ptr.String(jtv) 10836 } 10837 10838 case "ipAddress": 10839 if value != nil { 10840 jtv, ok := value.(string) 10841 if !ok { 10842 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10843 } 10844 sv.IpAddress = ptr.String(jtv) 10845 } 10846 10847 default: 10848 _, _ = key, value 10849 10850 } 10851 } 10852 *v = sv 10853 return nil 10854} 10855 10856func awsAwsjson11_deserializeDocumentHostEntryList(v *[]types.HostEntry, value interface{}) error { 10857 if v == nil { 10858 return fmt.Errorf("unexpected nil of type %T", v) 10859 } 10860 if value == nil { 10861 return nil 10862 } 10863 10864 shape, ok := value.([]interface{}) 10865 if !ok { 10866 return fmt.Errorf("unexpected JSON type %v", value) 10867 } 10868 10869 var cv []types.HostEntry 10870 if *v == nil { 10871 cv = []types.HostEntry{} 10872 } else { 10873 cv = *v 10874 } 10875 10876 for _, value := range shape { 10877 var col types.HostEntry 10878 destAddr := &col 10879 if err := awsAwsjson11_deserializeDocumentHostEntry(&destAddr, value); err != nil { 10880 return err 10881 } 10882 col = *destAddr 10883 cv = append(cv, col) 10884 10885 } 10886 *v = cv 10887 return nil 10888} 10889 10890func awsAwsjson11_deserializeDocumentHostVolumeProperties(v **types.HostVolumeProperties, value interface{}) error { 10891 if v == nil { 10892 return fmt.Errorf("unexpected nil of type %T", v) 10893 } 10894 if value == nil { 10895 return nil 10896 } 10897 10898 shape, ok := value.(map[string]interface{}) 10899 if !ok { 10900 return fmt.Errorf("unexpected JSON type %v", value) 10901 } 10902 10903 var sv *types.HostVolumeProperties 10904 if *v == nil { 10905 sv = &types.HostVolumeProperties{} 10906 } else { 10907 sv = *v 10908 } 10909 10910 for key, value := range shape { 10911 switch key { 10912 case "sourcePath": 10913 if value != nil { 10914 jtv, ok := value.(string) 10915 if !ok { 10916 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10917 } 10918 sv.SourcePath = ptr.String(jtv) 10919 } 10920 10921 default: 10922 _, _ = key, value 10923 10924 } 10925 } 10926 *v = sv 10927 return nil 10928} 10929 10930func awsAwsjson11_deserializeDocumentInferenceAccelerator(v **types.InferenceAccelerator, value interface{}) error { 10931 if v == nil { 10932 return fmt.Errorf("unexpected nil of type %T", v) 10933 } 10934 if value == nil { 10935 return nil 10936 } 10937 10938 shape, ok := value.(map[string]interface{}) 10939 if !ok { 10940 return fmt.Errorf("unexpected JSON type %v", value) 10941 } 10942 10943 var sv *types.InferenceAccelerator 10944 if *v == nil { 10945 sv = &types.InferenceAccelerator{} 10946 } else { 10947 sv = *v 10948 } 10949 10950 for key, value := range shape { 10951 switch key { 10952 case "deviceName": 10953 if value != nil { 10954 jtv, ok := value.(string) 10955 if !ok { 10956 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10957 } 10958 sv.DeviceName = ptr.String(jtv) 10959 } 10960 10961 case "deviceType": 10962 if value != nil { 10963 jtv, ok := value.(string) 10964 if !ok { 10965 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10966 } 10967 sv.DeviceType = ptr.String(jtv) 10968 } 10969 10970 default: 10971 _, _ = key, value 10972 10973 } 10974 } 10975 *v = sv 10976 return nil 10977} 10978 10979func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(v **types.InferenceAcceleratorOverride, value interface{}) error { 10980 if v == nil { 10981 return fmt.Errorf("unexpected nil of type %T", v) 10982 } 10983 if value == nil { 10984 return nil 10985 } 10986 10987 shape, ok := value.(map[string]interface{}) 10988 if !ok { 10989 return fmt.Errorf("unexpected JSON type %v", value) 10990 } 10991 10992 var sv *types.InferenceAcceleratorOverride 10993 if *v == nil { 10994 sv = &types.InferenceAcceleratorOverride{} 10995 } else { 10996 sv = *v 10997 } 10998 10999 for key, value := range shape { 11000 switch key { 11001 case "deviceName": 11002 if value != nil { 11003 jtv, ok := value.(string) 11004 if !ok { 11005 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11006 } 11007 sv.DeviceName = ptr.String(jtv) 11008 } 11009 11010 case "deviceType": 11011 if value != nil { 11012 jtv, ok := value.(string) 11013 if !ok { 11014 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11015 } 11016 sv.DeviceType = ptr.String(jtv) 11017 } 11018 11019 default: 11020 _, _ = key, value 11021 11022 } 11023 } 11024 *v = sv 11025 return nil 11026} 11027 11028func awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(v *[]types.InferenceAcceleratorOverride, value interface{}) error { 11029 if v == nil { 11030 return fmt.Errorf("unexpected nil of type %T", v) 11031 } 11032 if value == nil { 11033 return nil 11034 } 11035 11036 shape, ok := value.([]interface{}) 11037 if !ok { 11038 return fmt.Errorf("unexpected JSON type %v", value) 11039 } 11040 11041 var cv []types.InferenceAcceleratorOverride 11042 if *v == nil { 11043 cv = []types.InferenceAcceleratorOverride{} 11044 } else { 11045 cv = *v 11046 } 11047 11048 for _, value := range shape { 11049 var col types.InferenceAcceleratorOverride 11050 destAddr := &col 11051 if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverride(&destAddr, value); err != nil { 11052 return err 11053 } 11054 col = *destAddr 11055 cv = append(cv, col) 11056 11057 } 11058 *v = cv 11059 return nil 11060} 11061 11062func awsAwsjson11_deserializeDocumentInferenceAccelerators(v *[]types.InferenceAccelerator, value interface{}) error { 11063 if v == nil { 11064 return fmt.Errorf("unexpected nil of type %T", v) 11065 } 11066 if value == nil { 11067 return nil 11068 } 11069 11070 shape, ok := value.([]interface{}) 11071 if !ok { 11072 return fmt.Errorf("unexpected JSON type %v", value) 11073 } 11074 11075 var cv []types.InferenceAccelerator 11076 if *v == nil { 11077 cv = []types.InferenceAccelerator{} 11078 } else { 11079 cv = *v 11080 } 11081 11082 for _, value := range shape { 11083 var col types.InferenceAccelerator 11084 destAddr := &col 11085 if err := awsAwsjson11_deserializeDocumentInferenceAccelerator(&destAddr, value); err != nil { 11086 return err 11087 } 11088 col = *destAddr 11089 cv = append(cv, col) 11090 11091 } 11092 *v = cv 11093 return nil 11094} 11095 11096func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 11097 if v == nil { 11098 return fmt.Errorf("unexpected nil of type %T", v) 11099 } 11100 if value == nil { 11101 return nil 11102 } 11103 11104 shape, ok := value.(map[string]interface{}) 11105 if !ok { 11106 return fmt.Errorf("unexpected JSON type %v", value) 11107 } 11108 11109 var sv *types.InvalidParameterException 11110 if *v == nil { 11111 sv = &types.InvalidParameterException{} 11112 } else { 11113 sv = *v 11114 } 11115 11116 for key, value := range shape { 11117 switch key { 11118 case "message": 11119 if value != nil { 11120 jtv, ok := value.(string) 11121 if !ok { 11122 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11123 } 11124 sv.Message = ptr.String(jtv) 11125 } 11126 11127 default: 11128 _, _ = key, value 11129 11130 } 11131 } 11132 *v = sv 11133 return nil 11134} 11135 11136func awsAwsjson11_deserializeDocumentKernelCapabilities(v **types.KernelCapabilities, value interface{}) error { 11137 if v == nil { 11138 return fmt.Errorf("unexpected nil of type %T", v) 11139 } 11140 if value == nil { 11141 return nil 11142 } 11143 11144 shape, ok := value.(map[string]interface{}) 11145 if !ok { 11146 return fmt.Errorf("unexpected JSON type %v", value) 11147 } 11148 11149 var sv *types.KernelCapabilities 11150 if *v == nil { 11151 sv = &types.KernelCapabilities{} 11152 } else { 11153 sv = *v 11154 } 11155 11156 for key, value := range shape { 11157 switch key { 11158 case "add": 11159 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Add, value); err != nil { 11160 return err 11161 } 11162 11163 case "drop": 11164 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Drop, value); err != nil { 11165 return err 11166 } 11167 11168 default: 11169 _, _ = key, value 11170 11171 } 11172 } 11173 *v = sv 11174 return nil 11175} 11176 11177func awsAwsjson11_deserializeDocumentKeyValuePair(v **types.KeyValuePair, value interface{}) error { 11178 if v == nil { 11179 return fmt.Errorf("unexpected nil of type %T", v) 11180 } 11181 if value == nil { 11182 return nil 11183 } 11184 11185 shape, ok := value.(map[string]interface{}) 11186 if !ok { 11187 return fmt.Errorf("unexpected JSON type %v", value) 11188 } 11189 11190 var sv *types.KeyValuePair 11191 if *v == nil { 11192 sv = &types.KeyValuePair{} 11193 } else { 11194 sv = *v 11195 } 11196 11197 for key, value := range shape { 11198 switch key { 11199 case "name": 11200 if value != nil { 11201 jtv, ok := value.(string) 11202 if !ok { 11203 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11204 } 11205 sv.Name = ptr.String(jtv) 11206 } 11207 11208 case "value": 11209 if value != nil { 11210 jtv, ok := value.(string) 11211 if !ok { 11212 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11213 } 11214 sv.Value = ptr.String(jtv) 11215 } 11216 11217 default: 11218 _, _ = key, value 11219 11220 } 11221 } 11222 *v = sv 11223 return nil 11224} 11225 11226func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 11227 if v == nil { 11228 return fmt.Errorf("unexpected nil of type %T", v) 11229 } 11230 if value == nil { 11231 return nil 11232 } 11233 11234 shape, ok := value.(map[string]interface{}) 11235 if !ok { 11236 return fmt.Errorf("unexpected JSON type %v", value) 11237 } 11238 11239 var sv *types.LimitExceededException 11240 if *v == nil { 11241 sv = &types.LimitExceededException{} 11242 } else { 11243 sv = *v 11244 } 11245 11246 for key, value := range shape { 11247 switch key { 11248 case "message": 11249 if value != nil { 11250 jtv, ok := value.(string) 11251 if !ok { 11252 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11253 } 11254 sv.Message = ptr.String(jtv) 11255 } 11256 11257 default: 11258 _, _ = key, value 11259 11260 } 11261 } 11262 *v = sv 11263 return nil 11264} 11265 11266func awsAwsjson11_deserializeDocumentLinuxParameters(v **types.LinuxParameters, value interface{}) error { 11267 if v == nil { 11268 return fmt.Errorf("unexpected nil of type %T", v) 11269 } 11270 if value == nil { 11271 return nil 11272 } 11273 11274 shape, ok := value.(map[string]interface{}) 11275 if !ok { 11276 return fmt.Errorf("unexpected JSON type %v", value) 11277 } 11278 11279 var sv *types.LinuxParameters 11280 if *v == nil { 11281 sv = &types.LinuxParameters{} 11282 } else { 11283 sv = *v 11284 } 11285 11286 for key, value := range shape { 11287 switch key { 11288 case "capabilities": 11289 if err := awsAwsjson11_deserializeDocumentKernelCapabilities(&sv.Capabilities, value); err != nil { 11290 return err 11291 } 11292 11293 case "devices": 11294 if err := awsAwsjson11_deserializeDocumentDevicesList(&sv.Devices, value); err != nil { 11295 return err 11296 } 11297 11298 case "initProcessEnabled": 11299 if value != nil { 11300 jtv, ok := value.(bool) 11301 if !ok { 11302 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 11303 } 11304 sv.InitProcessEnabled = ptr.Bool(jtv) 11305 } 11306 11307 case "maxSwap": 11308 if value != nil { 11309 jtv, ok := value.(json.Number) 11310 if !ok { 11311 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11312 } 11313 i64, err := jtv.Int64() 11314 if err != nil { 11315 return err 11316 } 11317 sv.MaxSwap = ptr.Int32(int32(i64)) 11318 } 11319 11320 case "sharedMemorySize": 11321 if value != nil { 11322 jtv, ok := value.(json.Number) 11323 if !ok { 11324 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11325 } 11326 i64, err := jtv.Int64() 11327 if err != nil { 11328 return err 11329 } 11330 sv.SharedMemorySize = ptr.Int32(int32(i64)) 11331 } 11332 11333 case "swappiness": 11334 if value != nil { 11335 jtv, ok := value.(json.Number) 11336 if !ok { 11337 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11338 } 11339 i64, err := jtv.Int64() 11340 if err != nil { 11341 return err 11342 } 11343 sv.Swappiness = ptr.Int32(int32(i64)) 11344 } 11345 11346 case "tmpfs": 11347 if err := awsAwsjson11_deserializeDocumentTmpfsList(&sv.Tmpfs, value); err != nil { 11348 return err 11349 } 11350 11351 default: 11352 _, _ = key, value 11353 11354 } 11355 } 11356 *v = sv 11357 return nil 11358} 11359 11360func awsAwsjson11_deserializeDocumentLoadBalancer(v **types.LoadBalancer, value interface{}) error { 11361 if v == nil { 11362 return fmt.Errorf("unexpected nil of type %T", v) 11363 } 11364 if value == nil { 11365 return nil 11366 } 11367 11368 shape, ok := value.(map[string]interface{}) 11369 if !ok { 11370 return fmt.Errorf("unexpected JSON type %v", value) 11371 } 11372 11373 var sv *types.LoadBalancer 11374 if *v == nil { 11375 sv = &types.LoadBalancer{} 11376 } else { 11377 sv = *v 11378 } 11379 11380 for key, value := range shape { 11381 switch key { 11382 case "containerName": 11383 if value != nil { 11384 jtv, ok := value.(string) 11385 if !ok { 11386 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11387 } 11388 sv.ContainerName = ptr.String(jtv) 11389 } 11390 11391 case "containerPort": 11392 if value != nil { 11393 jtv, ok := value.(json.Number) 11394 if !ok { 11395 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11396 } 11397 i64, err := jtv.Int64() 11398 if err != nil { 11399 return err 11400 } 11401 sv.ContainerPort = ptr.Int32(int32(i64)) 11402 } 11403 11404 case "loadBalancerName": 11405 if value != nil { 11406 jtv, ok := value.(string) 11407 if !ok { 11408 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11409 } 11410 sv.LoadBalancerName = ptr.String(jtv) 11411 } 11412 11413 case "targetGroupArn": 11414 if value != nil { 11415 jtv, ok := value.(string) 11416 if !ok { 11417 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11418 } 11419 sv.TargetGroupArn = ptr.String(jtv) 11420 } 11421 11422 default: 11423 _, _ = key, value 11424 11425 } 11426 } 11427 *v = sv 11428 return nil 11429} 11430 11431func awsAwsjson11_deserializeDocumentLoadBalancers(v *[]types.LoadBalancer, value interface{}) error { 11432 if v == nil { 11433 return fmt.Errorf("unexpected nil of type %T", v) 11434 } 11435 if value == nil { 11436 return nil 11437 } 11438 11439 shape, ok := value.([]interface{}) 11440 if !ok { 11441 return fmt.Errorf("unexpected JSON type %v", value) 11442 } 11443 11444 var cv []types.LoadBalancer 11445 if *v == nil { 11446 cv = []types.LoadBalancer{} 11447 } else { 11448 cv = *v 11449 } 11450 11451 for _, value := range shape { 11452 var col types.LoadBalancer 11453 destAddr := &col 11454 if err := awsAwsjson11_deserializeDocumentLoadBalancer(&destAddr, value); err != nil { 11455 return err 11456 } 11457 col = *destAddr 11458 cv = append(cv, col) 11459 11460 } 11461 *v = cv 11462 return nil 11463} 11464 11465func awsAwsjson11_deserializeDocumentLogConfiguration(v **types.LogConfiguration, value interface{}) error { 11466 if v == nil { 11467 return fmt.Errorf("unexpected nil of type %T", v) 11468 } 11469 if value == nil { 11470 return nil 11471 } 11472 11473 shape, ok := value.(map[string]interface{}) 11474 if !ok { 11475 return fmt.Errorf("unexpected JSON type %v", value) 11476 } 11477 11478 var sv *types.LogConfiguration 11479 if *v == nil { 11480 sv = &types.LogConfiguration{} 11481 } else { 11482 sv = *v 11483 } 11484 11485 for key, value := range shape { 11486 switch key { 11487 case "logDriver": 11488 if value != nil { 11489 jtv, ok := value.(string) 11490 if !ok { 11491 return fmt.Errorf("expected LogDriver to be of type string, got %T instead", value) 11492 } 11493 sv.LogDriver = types.LogDriver(jtv) 11494 } 11495 11496 case "options": 11497 if err := awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(&sv.Options, value); err != nil { 11498 return err 11499 } 11500 11501 case "secretOptions": 11502 if err := awsAwsjson11_deserializeDocumentSecretList(&sv.SecretOptions, value); err != nil { 11503 return err 11504 } 11505 11506 default: 11507 _, _ = key, value 11508 11509 } 11510 } 11511 *v = sv 11512 return nil 11513} 11514 11515func awsAwsjson11_deserializeDocumentLogConfigurationOptionsMap(v *map[string]string, value interface{}) error { 11516 if v == nil { 11517 return fmt.Errorf("unexpected nil of type %T", v) 11518 } 11519 if value == nil { 11520 return nil 11521 } 11522 11523 shape, ok := value.(map[string]interface{}) 11524 if !ok { 11525 return fmt.Errorf("unexpected JSON type %v", value) 11526 } 11527 11528 var mv map[string]string 11529 if *v == nil { 11530 mv = map[string]string{} 11531 } else { 11532 mv = *v 11533 } 11534 11535 for key, value := range shape { 11536 var parsedVal string 11537 if value != nil { 11538 jtv, ok := value.(string) 11539 if !ok { 11540 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11541 } 11542 parsedVal = jtv 11543 } 11544 mv[key] = parsedVal 11545 11546 } 11547 *v = mv 11548 return nil 11549} 11550 11551func awsAwsjson11_deserializeDocumentManagedAgent(v **types.ManagedAgent, value interface{}) error { 11552 if v == nil { 11553 return fmt.Errorf("unexpected nil of type %T", v) 11554 } 11555 if value == nil { 11556 return nil 11557 } 11558 11559 shape, ok := value.(map[string]interface{}) 11560 if !ok { 11561 return fmt.Errorf("unexpected JSON type %v", value) 11562 } 11563 11564 var sv *types.ManagedAgent 11565 if *v == nil { 11566 sv = &types.ManagedAgent{} 11567 } else { 11568 sv = *v 11569 } 11570 11571 for key, value := range shape { 11572 switch key { 11573 case "lastStartedAt": 11574 if value != nil { 11575 jtv, ok := value.(json.Number) 11576 if !ok { 11577 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 11578 } 11579 f64, err := jtv.Float64() 11580 if err != nil { 11581 return err 11582 } 11583 sv.LastStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11584 } 11585 11586 case "lastStatus": 11587 if value != nil { 11588 jtv, ok := value.(string) 11589 if !ok { 11590 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11591 } 11592 sv.LastStatus = ptr.String(jtv) 11593 } 11594 11595 case "name": 11596 if value != nil { 11597 jtv, ok := value.(string) 11598 if !ok { 11599 return fmt.Errorf("expected ManagedAgentName to be of type string, got %T instead", value) 11600 } 11601 sv.Name = types.ManagedAgentName(jtv) 11602 } 11603 11604 case "reason": 11605 if value != nil { 11606 jtv, ok := value.(string) 11607 if !ok { 11608 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11609 } 11610 sv.Reason = ptr.String(jtv) 11611 } 11612 11613 default: 11614 _, _ = key, value 11615 11616 } 11617 } 11618 *v = sv 11619 return nil 11620} 11621 11622func awsAwsjson11_deserializeDocumentManagedAgents(v *[]types.ManagedAgent, value interface{}) error { 11623 if v == nil { 11624 return fmt.Errorf("unexpected nil of type %T", v) 11625 } 11626 if value == nil { 11627 return nil 11628 } 11629 11630 shape, ok := value.([]interface{}) 11631 if !ok { 11632 return fmt.Errorf("unexpected JSON type %v", value) 11633 } 11634 11635 var cv []types.ManagedAgent 11636 if *v == nil { 11637 cv = []types.ManagedAgent{} 11638 } else { 11639 cv = *v 11640 } 11641 11642 for _, value := range shape { 11643 var col types.ManagedAgent 11644 destAddr := &col 11645 if err := awsAwsjson11_deserializeDocumentManagedAgent(&destAddr, value); err != nil { 11646 return err 11647 } 11648 col = *destAddr 11649 cv = append(cv, col) 11650 11651 } 11652 *v = cv 11653 return nil 11654} 11655 11656func awsAwsjson11_deserializeDocumentManagedScaling(v **types.ManagedScaling, value interface{}) error { 11657 if v == nil { 11658 return fmt.Errorf("unexpected nil of type %T", v) 11659 } 11660 if value == nil { 11661 return nil 11662 } 11663 11664 shape, ok := value.(map[string]interface{}) 11665 if !ok { 11666 return fmt.Errorf("unexpected JSON type %v", value) 11667 } 11668 11669 var sv *types.ManagedScaling 11670 if *v == nil { 11671 sv = &types.ManagedScaling{} 11672 } else { 11673 sv = *v 11674 } 11675 11676 for key, value := range shape { 11677 switch key { 11678 case "instanceWarmupPeriod": 11679 if value != nil { 11680 jtv, ok := value.(json.Number) 11681 if !ok { 11682 return fmt.Errorf("expected ManagedScalingInstanceWarmupPeriod to be json.Number, got %T instead", value) 11683 } 11684 i64, err := jtv.Int64() 11685 if err != nil { 11686 return err 11687 } 11688 sv.InstanceWarmupPeriod = ptr.Int32(int32(i64)) 11689 } 11690 11691 case "maximumScalingStepSize": 11692 if value != nil { 11693 jtv, ok := value.(json.Number) 11694 if !ok { 11695 return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value) 11696 } 11697 i64, err := jtv.Int64() 11698 if err != nil { 11699 return err 11700 } 11701 sv.MaximumScalingStepSize = ptr.Int32(int32(i64)) 11702 } 11703 11704 case "minimumScalingStepSize": 11705 if value != nil { 11706 jtv, ok := value.(json.Number) 11707 if !ok { 11708 return fmt.Errorf("expected ManagedScalingStepSize to be json.Number, got %T instead", value) 11709 } 11710 i64, err := jtv.Int64() 11711 if err != nil { 11712 return err 11713 } 11714 sv.MinimumScalingStepSize = ptr.Int32(int32(i64)) 11715 } 11716 11717 case "status": 11718 if value != nil { 11719 jtv, ok := value.(string) 11720 if !ok { 11721 return fmt.Errorf("expected ManagedScalingStatus to be of type string, got %T instead", value) 11722 } 11723 sv.Status = types.ManagedScalingStatus(jtv) 11724 } 11725 11726 case "targetCapacity": 11727 if value != nil { 11728 jtv, ok := value.(json.Number) 11729 if !ok { 11730 return fmt.Errorf("expected ManagedScalingTargetCapacity to be json.Number, got %T instead", value) 11731 } 11732 i64, err := jtv.Int64() 11733 if err != nil { 11734 return err 11735 } 11736 sv.TargetCapacity = ptr.Int32(int32(i64)) 11737 } 11738 11739 default: 11740 _, _ = key, value 11741 11742 } 11743 } 11744 *v = sv 11745 return nil 11746} 11747 11748func awsAwsjson11_deserializeDocumentMissingVersionException(v **types.MissingVersionException, value interface{}) error { 11749 if v == nil { 11750 return fmt.Errorf("unexpected nil of type %T", v) 11751 } 11752 if value == nil { 11753 return nil 11754 } 11755 11756 shape, ok := value.(map[string]interface{}) 11757 if !ok { 11758 return fmt.Errorf("unexpected JSON type %v", value) 11759 } 11760 11761 var sv *types.MissingVersionException 11762 if *v == nil { 11763 sv = &types.MissingVersionException{} 11764 } else { 11765 sv = *v 11766 } 11767 11768 for key, value := range shape { 11769 switch key { 11770 case "message": 11771 if value != nil { 11772 jtv, ok := value.(string) 11773 if !ok { 11774 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11775 } 11776 sv.Message = ptr.String(jtv) 11777 } 11778 11779 default: 11780 _, _ = key, value 11781 11782 } 11783 } 11784 *v = sv 11785 return nil 11786} 11787 11788func awsAwsjson11_deserializeDocumentMountPoint(v **types.MountPoint, value interface{}) error { 11789 if v == nil { 11790 return fmt.Errorf("unexpected nil of type %T", v) 11791 } 11792 if value == nil { 11793 return nil 11794 } 11795 11796 shape, ok := value.(map[string]interface{}) 11797 if !ok { 11798 return fmt.Errorf("unexpected JSON type %v", value) 11799 } 11800 11801 var sv *types.MountPoint 11802 if *v == nil { 11803 sv = &types.MountPoint{} 11804 } else { 11805 sv = *v 11806 } 11807 11808 for key, value := range shape { 11809 switch key { 11810 case "containerPath": 11811 if value != nil { 11812 jtv, ok := value.(string) 11813 if !ok { 11814 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11815 } 11816 sv.ContainerPath = ptr.String(jtv) 11817 } 11818 11819 case "readOnly": 11820 if value != nil { 11821 jtv, ok := value.(bool) 11822 if !ok { 11823 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 11824 } 11825 sv.ReadOnly = ptr.Bool(jtv) 11826 } 11827 11828 case "sourceVolume": 11829 if value != nil { 11830 jtv, ok := value.(string) 11831 if !ok { 11832 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11833 } 11834 sv.SourceVolume = ptr.String(jtv) 11835 } 11836 11837 default: 11838 _, _ = key, value 11839 11840 } 11841 } 11842 *v = sv 11843 return nil 11844} 11845 11846func awsAwsjson11_deserializeDocumentMountPointList(v *[]types.MountPoint, value interface{}) error { 11847 if v == nil { 11848 return fmt.Errorf("unexpected nil of type %T", v) 11849 } 11850 if value == nil { 11851 return nil 11852 } 11853 11854 shape, ok := value.([]interface{}) 11855 if !ok { 11856 return fmt.Errorf("unexpected JSON type %v", value) 11857 } 11858 11859 var cv []types.MountPoint 11860 if *v == nil { 11861 cv = []types.MountPoint{} 11862 } else { 11863 cv = *v 11864 } 11865 11866 for _, value := range shape { 11867 var col types.MountPoint 11868 destAddr := &col 11869 if err := awsAwsjson11_deserializeDocumentMountPoint(&destAddr, value); err != nil { 11870 return err 11871 } 11872 col = *destAddr 11873 cv = append(cv, col) 11874 11875 } 11876 *v = cv 11877 return nil 11878} 11879 11880func awsAwsjson11_deserializeDocumentNetworkBinding(v **types.NetworkBinding, value interface{}) error { 11881 if v == nil { 11882 return fmt.Errorf("unexpected nil of type %T", v) 11883 } 11884 if value == nil { 11885 return nil 11886 } 11887 11888 shape, ok := value.(map[string]interface{}) 11889 if !ok { 11890 return fmt.Errorf("unexpected JSON type %v", value) 11891 } 11892 11893 var sv *types.NetworkBinding 11894 if *v == nil { 11895 sv = &types.NetworkBinding{} 11896 } else { 11897 sv = *v 11898 } 11899 11900 for key, value := range shape { 11901 switch key { 11902 case "bindIP": 11903 if value != nil { 11904 jtv, ok := value.(string) 11905 if !ok { 11906 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11907 } 11908 sv.BindIP = ptr.String(jtv) 11909 } 11910 11911 case "containerPort": 11912 if value != nil { 11913 jtv, ok := value.(json.Number) 11914 if !ok { 11915 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11916 } 11917 i64, err := jtv.Int64() 11918 if err != nil { 11919 return err 11920 } 11921 sv.ContainerPort = ptr.Int32(int32(i64)) 11922 } 11923 11924 case "hostPort": 11925 if value != nil { 11926 jtv, ok := value.(json.Number) 11927 if !ok { 11928 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 11929 } 11930 i64, err := jtv.Int64() 11931 if err != nil { 11932 return err 11933 } 11934 sv.HostPort = ptr.Int32(int32(i64)) 11935 } 11936 11937 case "protocol": 11938 if value != nil { 11939 jtv, ok := value.(string) 11940 if !ok { 11941 return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value) 11942 } 11943 sv.Protocol = types.TransportProtocol(jtv) 11944 } 11945 11946 default: 11947 _, _ = key, value 11948 11949 } 11950 } 11951 *v = sv 11952 return nil 11953} 11954 11955func awsAwsjson11_deserializeDocumentNetworkBindings(v *[]types.NetworkBinding, value interface{}) error { 11956 if v == nil { 11957 return fmt.Errorf("unexpected nil of type %T", v) 11958 } 11959 if value == nil { 11960 return nil 11961 } 11962 11963 shape, ok := value.([]interface{}) 11964 if !ok { 11965 return fmt.Errorf("unexpected JSON type %v", value) 11966 } 11967 11968 var cv []types.NetworkBinding 11969 if *v == nil { 11970 cv = []types.NetworkBinding{} 11971 } else { 11972 cv = *v 11973 } 11974 11975 for _, value := range shape { 11976 var col types.NetworkBinding 11977 destAddr := &col 11978 if err := awsAwsjson11_deserializeDocumentNetworkBinding(&destAddr, value); err != nil { 11979 return err 11980 } 11981 col = *destAddr 11982 cv = append(cv, col) 11983 11984 } 11985 *v = cv 11986 return nil 11987} 11988 11989func awsAwsjson11_deserializeDocumentNetworkConfiguration(v **types.NetworkConfiguration, value interface{}) error { 11990 if v == nil { 11991 return fmt.Errorf("unexpected nil of type %T", v) 11992 } 11993 if value == nil { 11994 return nil 11995 } 11996 11997 shape, ok := value.(map[string]interface{}) 11998 if !ok { 11999 return fmt.Errorf("unexpected JSON type %v", value) 12000 } 12001 12002 var sv *types.NetworkConfiguration 12003 if *v == nil { 12004 sv = &types.NetworkConfiguration{} 12005 } else { 12006 sv = *v 12007 } 12008 12009 for key, value := range shape { 12010 switch key { 12011 case "awsvpcConfiguration": 12012 if err := awsAwsjson11_deserializeDocumentAwsVpcConfiguration(&sv.AwsvpcConfiguration, value); err != nil { 12013 return err 12014 } 12015 12016 default: 12017 _, _ = key, value 12018 12019 } 12020 } 12021 *v = sv 12022 return nil 12023} 12024 12025func awsAwsjson11_deserializeDocumentNetworkInterface(v **types.NetworkInterface, value interface{}) error { 12026 if v == nil { 12027 return fmt.Errorf("unexpected nil of type %T", v) 12028 } 12029 if value == nil { 12030 return nil 12031 } 12032 12033 shape, ok := value.(map[string]interface{}) 12034 if !ok { 12035 return fmt.Errorf("unexpected JSON type %v", value) 12036 } 12037 12038 var sv *types.NetworkInterface 12039 if *v == nil { 12040 sv = &types.NetworkInterface{} 12041 } else { 12042 sv = *v 12043 } 12044 12045 for key, value := range shape { 12046 switch key { 12047 case "attachmentId": 12048 if value != nil { 12049 jtv, ok := value.(string) 12050 if !ok { 12051 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12052 } 12053 sv.AttachmentId = ptr.String(jtv) 12054 } 12055 12056 case "ipv6Address": 12057 if value != nil { 12058 jtv, ok := value.(string) 12059 if !ok { 12060 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12061 } 12062 sv.Ipv6Address = ptr.String(jtv) 12063 } 12064 12065 case "privateIpv4Address": 12066 if value != nil { 12067 jtv, ok := value.(string) 12068 if !ok { 12069 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12070 } 12071 sv.PrivateIpv4Address = ptr.String(jtv) 12072 } 12073 12074 default: 12075 _, _ = key, value 12076 12077 } 12078 } 12079 *v = sv 12080 return nil 12081} 12082 12083func awsAwsjson11_deserializeDocumentNetworkInterfaces(v *[]types.NetworkInterface, value interface{}) error { 12084 if v == nil { 12085 return fmt.Errorf("unexpected nil of type %T", v) 12086 } 12087 if value == nil { 12088 return nil 12089 } 12090 12091 shape, ok := value.([]interface{}) 12092 if !ok { 12093 return fmt.Errorf("unexpected JSON type %v", value) 12094 } 12095 12096 var cv []types.NetworkInterface 12097 if *v == nil { 12098 cv = []types.NetworkInterface{} 12099 } else { 12100 cv = *v 12101 } 12102 12103 for _, value := range shape { 12104 var col types.NetworkInterface 12105 destAddr := &col 12106 if err := awsAwsjson11_deserializeDocumentNetworkInterface(&destAddr, value); err != nil { 12107 return err 12108 } 12109 col = *destAddr 12110 cv = append(cv, col) 12111 12112 } 12113 *v = cv 12114 return nil 12115} 12116 12117func awsAwsjson11_deserializeDocumentNoUpdateAvailableException(v **types.NoUpdateAvailableException, value interface{}) error { 12118 if v == nil { 12119 return fmt.Errorf("unexpected nil of type %T", v) 12120 } 12121 if value == nil { 12122 return nil 12123 } 12124 12125 shape, ok := value.(map[string]interface{}) 12126 if !ok { 12127 return fmt.Errorf("unexpected JSON type %v", value) 12128 } 12129 12130 var sv *types.NoUpdateAvailableException 12131 if *v == nil { 12132 sv = &types.NoUpdateAvailableException{} 12133 } else { 12134 sv = *v 12135 } 12136 12137 for key, value := range shape { 12138 switch key { 12139 case "message": 12140 if value != nil { 12141 jtv, ok := value.(string) 12142 if !ok { 12143 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12144 } 12145 sv.Message = ptr.String(jtv) 12146 } 12147 12148 default: 12149 _, _ = key, value 12150 12151 } 12152 } 12153 *v = sv 12154 return nil 12155} 12156 12157func awsAwsjson11_deserializeDocumentPlacementConstraint(v **types.PlacementConstraint, value interface{}) error { 12158 if v == nil { 12159 return fmt.Errorf("unexpected nil of type %T", v) 12160 } 12161 if value == nil { 12162 return nil 12163 } 12164 12165 shape, ok := value.(map[string]interface{}) 12166 if !ok { 12167 return fmt.Errorf("unexpected JSON type %v", value) 12168 } 12169 12170 var sv *types.PlacementConstraint 12171 if *v == nil { 12172 sv = &types.PlacementConstraint{} 12173 } else { 12174 sv = *v 12175 } 12176 12177 for key, value := range shape { 12178 switch key { 12179 case "expression": 12180 if value != nil { 12181 jtv, ok := value.(string) 12182 if !ok { 12183 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12184 } 12185 sv.Expression = ptr.String(jtv) 12186 } 12187 12188 case "type": 12189 if value != nil { 12190 jtv, ok := value.(string) 12191 if !ok { 12192 return fmt.Errorf("expected PlacementConstraintType to be of type string, got %T instead", value) 12193 } 12194 sv.Type = types.PlacementConstraintType(jtv) 12195 } 12196 12197 default: 12198 _, _ = key, value 12199 12200 } 12201 } 12202 *v = sv 12203 return nil 12204} 12205 12206func awsAwsjson11_deserializeDocumentPlacementConstraints(v *[]types.PlacementConstraint, value interface{}) error { 12207 if v == nil { 12208 return fmt.Errorf("unexpected nil of type %T", v) 12209 } 12210 if value == nil { 12211 return nil 12212 } 12213 12214 shape, ok := value.([]interface{}) 12215 if !ok { 12216 return fmt.Errorf("unexpected JSON type %v", value) 12217 } 12218 12219 var cv []types.PlacementConstraint 12220 if *v == nil { 12221 cv = []types.PlacementConstraint{} 12222 } else { 12223 cv = *v 12224 } 12225 12226 for _, value := range shape { 12227 var col types.PlacementConstraint 12228 destAddr := &col 12229 if err := awsAwsjson11_deserializeDocumentPlacementConstraint(&destAddr, value); err != nil { 12230 return err 12231 } 12232 col = *destAddr 12233 cv = append(cv, col) 12234 12235 } 12236 *v = cv 12237 return nil 12238} 12239 12240func awsAwsjson11_deserializeDocumentPlacementStrategies(v *[]types.PlacementStrategy, value interface{}) error { 12241 if v == nil { 12242 return fmt.Errorf("unexpected nil of type %T", v) 12243 } 12244 if value == nil { 12245 return nil 12246 } 12247 12248 shape, ok := value.([]interface{}) 12249 if !ok { 12250 return fmt.Errorf("unexpected JSON type %v", value) 12251 } 12252 12253 var cv []types.PlacementStrategy 12254 if *v == nil { 12255 cv = []types.PlacementStrategy{} 12256 } else { 12257 cv = *v 12258 } 12259 12260 for _, value := range shape { 12261 var col types.PlacementStrategy 12262 destAddr := &col 12263 if err := awsAwsjson11_deserializeDocumentPlacementStrategy(&destAddr, value); err != nil { 12264 return err 12265 } 12266 col = *destAddr 12267 cv = append(cv, col) 12268 12269 } 12270 *v = cv 12271 return nil 12272} 12273 12274func awsAwsjson11_deserializeDocumentPlacementStrategy(v **types.PlacementStrategy, value interface{}) error { 12275 if v == nil { 12276 return fmt.Errorf("unexpected nil of type %T", v) 12277 } 12278 if value == nil { 12279 return nil 12280 } 12281 12282 shape, ok := value.(map[string]interface{}) 12283 if !ok { 12284 return fmt.Errorf("unexpected JSON type %v", value) 12285 } 12286 12287 var sv *types.PlacementStrategy 12288 if *v == nil { 12289 sv = &types.PlacementStrategy{} 12290 } else { 12291 sv = *v 12292 } 12293 12294 for key, value := range shape { 12295 switch key { 12296 case "field": 12297 if value != nil { 12298 jtv, ok := value.(string) 12299 if !ok { 12300 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12301 } 12302 sv.Field = ptr.String(jtv) 12303 } 12304 12305 case "type": 12306 if value != nil { 12307 jtv, ok := value.(string) 12308 if !ok { 12309 return fmt.Errorf("expected PlacementStrategyType to be of type string, got %T instead", value) 12310 } 12311 sv.Type = types.PlacementStrategyType(jtv) 12312 } 12313 12314 default: 12315 _, _ = key, value 12316 12317 } 12318 } 12319 *v = sv 12320 return nil 12321} 12322 12323func awsAwsjson11_deserializeDocumentPlatformTaskDefinitionIncompatibilityException(v **types.PlatformTaskDefinitionIncompatibilityException, value interface{}) error { 12324 if v == nil { 12325 return fmt.Errorf("unexpected nil of type %T", v) 12326 } 12327 if value == nil { 12328 return nil 12329 } 12330 12331 shape, ok := value.(map[string]interface{}) 12332 if !ok { 12333 return fmt.Errorf("unexpected JSON type %v", value) 12334 } 12335 12336 var sv *types.PlatformTaskDefinitionIncompatibilityException 12337 if *v == nil { 12338 sv = &types.PlatformTaskDefinitionIncompatibilityException{} 12339 } else { 12340 sv = *v 12341 } 12342 12343 for key, value := range shape { 12344 switch key { 12345 case "message": 12346 if value != nil { 12347 jtv, ok := value.(string) 12348 if !ok { 12349 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12350 } 12351 sv.Message = ptr.String(jtv) 12352 } 12353 12354 default: 12355 _, _ = key, value 12356 12357 } 12358 } 12359 *v = sv 12360 return nil 12361} 12362 12363func awsAwsjson11_deserializeDocumentPlatformUnknownException(v **types.PlatformUnknownException, value interface{}) error { 12364 if v == nil { 12365 return fmt.Errorf("unexpected nil of type %T", v) 12366 } 12367 if value == nil { 12368 return nil 12369 } 12370 12371 shape, ok := value.(map[string]interface{}) 12372 if !ok { 12373 return fmt.Errorf("unexpected JSON type %v", value) 12374 } 12375 12376 var sv *types.PlatformUnknownException 12377 if *v == nil { 12378 sv = &types.PlatformUnknownException{} 12379 } else { 12380 sv = *v 12381 } 12382 12383 for key, value := range shape { 12384 switch key { 12385 case "message": 12386 if value != nil { 12387 jtv, ok := value.(string) 12388 if !ok { 12389 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12390 } 12391 sv.Message = ptr.String(jtv) 12392 } 12393 12394 default: 12395 _, _ = key, value 12396 12397 } 12398 } 12399 *v = sv 12400 return nil 12401} 12402 12403func awsAwsjson11_deserializeDocumentPortMapping(v **types.PortMapping, value interface{}) error { 12404 if v == nil { 12405 return fmt.Errorf("unexpected nil of type %T", v) 12406 } 12407 if value == nil { 12408 return nil 12409 } 12410 12411 shape, ok := value.(map[string]interface{}) 12412 if !ok { 12413 return fmt.Errorf("unexpected JSON type %v", value) 12414 } 12415 12416 var sv *types.PortMapping 12417 if *v == nil { 12418 sv = &types.PortMapping{} 12419 } else { 12420 sv = *v 12421 } 12422 12423 for key, value := range shape { 12424 switch key { 12425 case "containerPort": 12426 if value != nil { 12427 jtv, ok := value.(json.Number) 12428 if !ok { 12429 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 12430 } 12431 i64, err := jtv.Int64() 12432 if err != nil { 12433 return err 12434 } 12435 sv.ContainerPort = ptr.Int32(int32(i64)) 12436 } 12437 12438 case "hostPort": 12439 if value != nil { 12440 jtv, ok := value.(json.Number) 12441 if !ok { 12442 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 12443 } 12444 i64, err := jtv.Int64() 12445 if err != nil { 12446 return err 12447 } 12448 sv.HostPort = ptr.Int32(int32(i64)) 12449 } 12450 12451 case "protocol": 12452 if value != nil { 12453 jtv, ok := value.(string) 12454 if !ok { 12455 return fmt.Errorf("expected TransportProtocol to be of type string, got %T instead", value) 12456 } 12457 sv.Protocol = types.TransportProtocol(jtv) 12458 } 12459 12460 default: 12461 _, _ = key, value 12462 12463 } 12464 } 12465 *v = sv 12466 return nil 12467} 12468 12469func awsAwsjson11_deserializeDocumentPortMappingList(v *[]types.PortMapping, value interface{}) error { 12470 if v == nil { 12471 return fmt.Errorf("unexpected nil of type %T", v) 12472 } 12473 if value == nil { 12474 return nil 12475 } 12476 12477 shape, ok := value.([]interface{}) 12478 if !ok { 12479 return fmt.Errorf("unexpected JSON type %v", value) 12480 } 12481 12482 var cv []types.PortMapping 12483 if *v == nil { 12484 cv = []types.PortMapping{} 12485 } else { 12486 cv = *v 12487 } 12488 12489 for _, value := range shape { 12490 var col types.PortMapping 12491 destAddr := &col 12492 if err := awsAwsjson11_deserializeDocumentPortMapping(&destAddr, value); err != nil { 12493 return err 12494 } 12495 col = *destAddr 12496 cv = append(cv, col) 12497 12498 } 12499 *v = cv 12500 return nil 12501} 12502 12503func awsAwsjson11_deserializeDocumentProxyConfiguration(v **types.ProxyConfiguration, value interface{}) error { 12504 if v == nil { 12505 return fmt.Errorf("unexpected nil of type %T", v) 12506 } 12507 if value == nil { 12508 return nil 12509 } 12510 12511 shape, ok := value.(map[string]interface{}) 12512 if !ok { 12513 return fmt.Errorf("unexpected JSON type %v", value) 12514 } 12515 12516 var sv *types.ProxyConfiguration 12517 if *v == nil { 12518 sv = &types.ProxyConfiguration{} 12519 } else { 12520 sv = *v 12521 } 12522 12523 for key, value := range shape { 12524 switch key { 12525 case "containerName": 12526 if value != nil { 12527 jtv, ok := value.(string) 12528 if !ok { 12529 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12530 } 12531 sv.ContainerName = ptr.String(jtv) 12532 } 12533 12534 case "properties": 12535 if err := awsAwsjson11_deserializeDocumentProxyConfigurationProperties(&sv.Properties, value); err != nil { 12536 return err 12537 } 12538 12539 case "type": 12540 if value != nil { 12541 jtv, ok := value.(string) 12542 if !ok { 12543 return fmt.Errorf("expected ProxyConfigurationType to be of type string, got %T instead", value) 12544 } 12545 sv.Type = types.ProxyConfigurationType(jtv) 12546 } 12547 12548 default: 12549 _, _ = key, value 12550 12551 } 12552 } 12553 *v = sv 12554 return nil 12555} 12556 12557func awsAwsjson11_deserializeDocumentProxyConfigurationProperties(v *[]types.KeyValuePair, value interface{}) error { 12558 if v == nil { 12559 return fmt.Errorf("unexpected nil of type %T", v) 12560 } 12561 if value == nil { 12562 return nil 12563 } 12564 12565 shape, ok := value.([]interface{}) 12566 if !ok { 12567 return fmt.Errorf("unexpected JSON type %v", value) 12568 } 12569 12570 var cv []types.KeyValuePair 12571 if *v == nil { 12572 cv = []types.KeyValuePair{} 12573 } else { 12574 cv = *v 12575 } 12576 12577 for _, value := range shape { 12578 var col types.KeyValuePair 12579 destAddr := &col 12580 if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 12581 return err 12582 } 12583 col = *destAddr 12584 cv = append(cv, col) 12585 12586 } 12587 *v = cv 12588 return nil 12589} 12590 12591func awsAwsjson11_deserializeDocumentRepositoryCredentials(v **types.RepositoryCredentials, value interface{}) error { 12592 if v == nil { 12593 return fmt.Errorf("unexpected nil of type %T", v) 12594 } 12595 if value == nil { 12596 return nil 12597 } 12598 12599 shape, ok := value.(map[string]interface{}) 12600 if !ok { 12601 return fmt.Errorf("unexpected JSON type %v", value) 12602 } 12603 12604 var sv *types.RepositoryCredentials 12605 if *v == nil { 12606 sv = &types.RepositoryCredentials{} 12607 } else { 12608 sv = *v 12609 } 12610 12611 for key, value := range shape { 12612 switch key { 12613 case "credentialsParameter": 12614 if value != nil { 12615 jtv, ok := value.(string) 12616 if !ok { 12617 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12618 } 12619 sv.CredentialsParameter = ptr.String(jtv) 12620 } 12621 12622 default: 12623 _, _ = key, value 12624 12625 } 12626 } 12627 *v = sv 12628 return nil 12629} 12630 12631func awsAwsjson11_deserializeDocumentRequiresAttributes(v *[]types.Attribute, value interface{}) error { 12632 if v == nil { 12633 return fmt.Errorf("unexpected nil of type %T", v) 12634 } 12635 if value == nil { 12636 return nil 12637 } 12638 12639 shape, ok := value.([]interface{}) 12640 if !ok { 12641 return fmt.Errorf("unexpected JSON type %v", value) 12642 } 12643 12644 var cv []types.Attribute 12645 if *v == nil { 12646 cv = []types.Attribute{} 12647 } else { 12648 cv = *v 12649 } 12650 12651 for _, value := range shape { 12652 var col types.Attribute 12653 destAddr := &col 12654 if err := awsAwsjson11_deserializeDocumentAttribute(&destAddr, value); err != nil { 12655 return err 12656 } 12657 col = *destAddr 12658 cv = append(cv, col) 12659 12660 } 12661 *v = cv 12662 return nil 12663} 12664 12665func awsAwsjson11_deserializeDocumentResource(v **types.Resource, value interface{}) error { 12666 if v == nil { 12667 return fmt.Errorf("unexpected nil of type %T", v) 12668 } 12669 if value == nil { 12670 return nil 12671 } 12672 12673 shape, ok := value.(map[string]interface{}) 12674 if !ok { 12675 return fmt.Errorf("unexpected JSON type %v", value) 12676 } 12677 12678 var sv *types.Resource 12679 if *v == nil { 12680 sv = &types.Resource{} 12681 } else { 12682 sv = *v 12683 } 12684 12685 for key, value := range shape { 12686 switch key { 12687 case "doubleValue": 12688 if value != nil { 12689 jtv, ok := value.(json.Number) 12690 if !ok { 12691 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 12692 } 12693 f64, err := jtv.Float64() 12694 if err != nil { 12695 return err 12696 } 12697 sv.DoubleValue = f64 12698 } 12699 12700 case "integerValue": 12701 if value != nil { 12702 jtv, ok := value.(json.Number) 12703 if !ok { 12704 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 12705 } 12706 i64, err := jtv.Int64() 12707 if err != nil { 12708 return err 12709 } 12710 sv.IntegerValue = int32(i64) 12711 } 12712 12713 case "longValue": 12714 if value != nil { 12715 jtv, ok := value.(json.Number) 12716 if !ok { 12717 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 12718 } 12719 i64, err := jtv.Int64() 12720 if err != nil { 12721 return err 12722 } 12723 sv.LongValue = i64 12724 } 12725 12726 case "name": 12727 if value != nil { 12728 jtv, ok := value.(string) 12729 if !ok { 12730 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12731 } 12732 sv.Name = ptr.String(jtv) 12733 } 12734 12735 case "stringSetValue": 12736 if err := awsAwsjson11_deserializeDocumentStringList(&sv.StringSetValue, value); err != nil { 12737 return err 12738 } 12739 12740 case "type": 12741 if value != nil { 12742 jtv, ok := value.(string) 12743 if !ok { 12744 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12745 } 12746 sv.Type = ptr.String(jtv) 12747 } 12748 12749 default: 12750 _, _ = key, value 12751 12752 } 12753 } 12754 *v = sv 12755 return nil 12756} 12757 12758func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 12759 if v == nil { 12760 return fmt.Errorf("unexpected nil of type %T", v) 12761 } 12762 if value == nil { 12763 return nil 12764 } 12765 12766 shape, ok := value.(map[string]interface{}) 12767 if !ok { 12768 return fmt.Errorf("unexpected JSON type %v", value) 12769 } 12770 12771 var sv *types.ResourceInUseException 12772 if *v == nil { 12773 sv = &types.ResourceInUseException{} 12774 } else { 12775 sv = *v 12776 } 12777 12778 for key, value := range shape { 12779 switch key { 12780 case "message": 12781 if value != nil { 12782 jtv, ok := value.(string) 12783 if !ok { 12784 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12785 } 12786 sv.Message = ptr.String(jtv) 12787 } 12788 12789 default: 12790 _, _ = key, value 12791 12792 } 12793 } 12794 *v = sv 12795 return nil 12796} 12797 12798func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 12799 if v == nil { 12800 return fmt.Errorf("unexpected nil of type %T", v) 12801 } 12802 if value == nil { 12803 return nil 12804 } 12805 12806 shape, ok := value.(map[string]interface{}) 12807 if !ok { 12808 return fmt.Errorf("unexpected JSON type %v", value) 12809 } 12810 12811 var sv *types.ResourceNotFoundException 12812 if *v == nil { 12813 sv = &types.ResourceNotFoundException{} 12814 } else { 12815 sv = *v 12816 } 12817 12818 for key, value := range shape { 12819 switch key { 12820 case "message": 12821 if value != nil { 12822 jtv, ok := value.(string) 12823 if !ok { 12824 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12825 } 12826 sv.Message = ptr.String(jtv) 12827 } 12828 12829 default: 12830 _, _ = key, value 12831 12832 } 12833 } 12834 *v = sv 12835 return nil 12836} 12837 12838func awsAwsjson11_deserializeDocumentResourceRequirement(v **types.ResourceRequirement, value interface{}) error { 12839 if v == nil { 12840 return fmt.Errorf("unexpected nil of type %T", v) 12841 } 12842 if value == nil { 12843 return nil 12844 } 12845 12846 shape, ok := value.(map[string]interface{}) 12847 if !ok { 12848 return fmt.Errorf("unexpected JSON type %v", value) 12849 } 12850 12851 var sv *types.ResourceRequirement 12852 if *v == nil { 12853 sv = &types.ResourceRequirement{} 12854 } else { 12855 sv = *v 12856 } 12857 12858 for key, value := range shape { 12859 switch key { 12860 case "type": 12861 if value != nil { 12862 jtv, ok := value.(string) 12863 if !ok { 12864 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 12865 } 12866 sv.Type = types.ResourceType(jtv) 12867 } 12868 12869 case "value": 12870 if value != nil { 12871 jtv, ok := value.(string) 12872 if !ok { 12873 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12874 } 12875 sv.Value = ptr.String(jtv) 12876 } 12877 12878 default: 12879 _, _ = key, value 12880 12881 } 12882 } 12883 *v = sv 12884 return nil 12885} 12886 12887func awsAwsjson11_deserializeDocumentResourceRequirements(v *[]types.ResourceRequirement, value interface{}) error { 12888 if v == nil { 12889 return fmt.Errorf("unexpected nil of type %T", v) 12890 } 12891 if value == nil { 12892 return nil 12893 } 12894 12895 shape, ok := value.([]interface{}) 12896 if !ok { 12897 return fmt.Errorf("unexpected JSON type %v", value) 12898 } 12899 12900 var cv []types.ResourceRequirement 12901 if *v == nil { 12902 cv = []types.ResourceRequirement{} 12903 } else { 12904 cv = *v 12905 } 12906 12907 for _, value := range shape { 12908 var col types.ResourceRequirement 12909 destAddr := &col 12910 if err := awsAwsjson11_deserializeDocumentResourceRequirement(&destAddr, value); err != nil { 12911 return err 12912 } 12913 col = *destAddr 12914 cv = append(cv, col) 12915 12916 } 12917 *v = cv 12918 return nil 12919} 12920 12921func awsAwsjson11_deserializeDocumentResources(v *[]types.Resource, value interface{}) error { 12922 if v == nil { 12923 return fmt.Errorf("unexpected nil of type %T", v) 12924 } 12925 if value == nil { 12926 return nil 12927 } 12928 12929 shape, ok := value.([]interface{}) 12930 if !ok { 12931 return fmt.Errorf("unexpected JSON type %v", value) 12932 } 12933 12934 var cv []types.Resource 12935 if *v == nil { 12936 cv = []types.Resource{} 12937 } else { 12938 cv = *v 12939 } 12940 12941 for _, value := range shape { 12942 var col types.Resource 12943 destAddr := &col 12944 if err := awsAwsjson11_deserializeDocumentResource(&destAddr, value); err != nil { 12945 return err 12946 } 12947 col = *destAddr 12948 cv = append(cv, col) 12949 12950 } 12951 *v = cv 12952 return nil 12953} 12954 12955func awsAwsjson11_deserializeDocumentScale(v **types.Scale, value interface{}) error { 12956 if v == nil { 12957 return fmt.Errorf("unexpected nil of type %T", v) 12958 } 12959 if value == nil { 12960 return nil 12961 } 12962 12963 shape, ok := value.(map[string]interface{}) 12964 if !ok { 12965 return fmt.Errorf("unexpected JSON type %v", value) 12966 } 12967 12968 var sv *types.Scale 12969 if *v == nil { 12970 sv = &types.Scale{} 12971 } else { 12972 sv = *v 12973 } 12974 12975 for key, value := range shape { 12976 switch key { 12977 case "unit": 12978 if value != nil { 12979 jtv, ok := value.(string) 12980 if !ok { 12981 return fmt.Errorf("expected ScaleUnit to be of type string, got %T instead", value) 12982 } 12983 sv.Unit = types.ScaleUnit(jtv) 12984 } 12985 12986 case "value": 12987 if value != nil { 12988 jtv, ok := value.(json.Number) 12989 if !ok { 12990 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 12991 } 12992 f64, err := jtv.Float64() 12993 if err != nil { 12994 return err 12995 } 12996 sv.Value = f64 12997 } 12998 12999 default: 13000 _, _ = key, value 13001 13002 } 13003 } 13004 *v = sv 13005 return nil 13006} 13007 13008func awsAwsjson11_deserializeDocumentSecret(v **types.Secret, value interface{}) error { 13009 if v == nil { 13010 return fmt.Errorf("unexpected nil of type %T", v) 13011 } 13012 if value == nil { 13013 return nil 13014 } 13015 13016 shape, ok := value.(map[string]interface{}) 13017 if !ok { 13018 return fmt.Errorf("unexpected JSON type %v", value) 13019 } 13020 13021 var sv *types.Secret 13022 if *v == nil { 13023 sv = &types.Secret{} 13024 } else { 13025 sv = *v 13026 } 13027 13028 for key, value := range shape { 13029 switch key { 13030 case "name": 13031 if value != nil { 13032 jtv, ok := value.(string) 13033 if !ok { 13034 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13035 } 13036 sv.Name = ptr.String(jtv) 13037 } 13038 13039 case "valueFrom": 13040 if value != nil { 13041 jtv, ok := value.(string) 13042 if !ok { 13043 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13044 } 13045 sv.ValueFrom = ptr.String(jtv) 13046 } 13047 13048 default: 13049 _, _ = key, value 13050 13051 } 13052 } 13053 *v = sv 13054 return nil 13055} 13056 13057func awsAwsjson11_deserializeDocumentSecretList(v *[]types.Secret, value interface{}) error { 13058 if v == nil { 13059 return fmt.Errorf("unexpected nil of type %T", v) 13060 } 13061 if value == nil { 13062 return nil 13063 } 13064 13065 shape, ok := value.([]interface{}) 13066 if !ok { 13067 return fmt.Errorf("unexpected JSON type %v", value) 13068 } 13069 13070 var cv []types.Secret 13071 if *v == nil { 13072 cv = []types.Secret{} 13073 } else { 13074 cv = *v 13075 } 13076 13077 for _, value := range shape { 13078 var col types.Secret 13079 destAddr := &col 13080 if err := awsAwsjson11_deserializeDocumentSecret(&destAddr, value); err != nil { 13081 return err 13082 } 13083 col = *destAddr 13084 cv = append(cv, col) 13085 13086 } 13087 *v = cv 13088 return nil 13089} 13090 13091func awsAwsjson11_deserializeDocumentServerException(v **types.ServerException, value interface{}) error { 13092 if v == nil { 13093 return fmt.Errorf("unexpected nil of type %T", v) 13094 } 13095 if value == nil { 13096 return nil 13097 } 13098 13099 shape, ok := value.(map[string]interface{}) 13100 if !ok { 13101 return fmt.Errorf("unexpected JSON type %v", value) 13102 } 13103 13104 var sv *types.ServerException 13105 if *v == nil { 13106 sv = &types.ServerException{} 13107 } else { 13108 sv = *v 13109 } 13110 13111 for key, value := range shape { 13112 switch key { 13113 case "message": 13114 if value != nil { 13115 jtv, ok := value.(string) 13116 if !ok { 13117 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13118 } 13119 sv.Message = ptr.String(jtv) 13120 } 13121 13122 default: 13123 _, _ = key, value 13124 13125 } 13126 } 13127 *v = sv 13128 return nil 13129} 13130 13131func awsAwsjson11_deserializeDocumentService(v **types.Service, value interface{}) error { 13132 if v == nil { 13133 return fmt.Errorf("unexpected nil of type %T", v) 13134 } 13135 if value == nil { 13136 return nil 13137 } 13138 13139 shape, ok := value.(map[string]interface{}) 13140 if !ok { 13141 return fmt.Errorf("unexpected JSON type %v", value) 13142 } 13143 13144 var sv *types.Service 13145 if *v == nil { 13146 sv = &types.Service{} 13147 } else { 13148 sv = *v 13149 } 13150 13151 for key, value := range shape { 13152 switch key { 13153 case "capacityProviderStrategy": 13154 if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil { 13155 return err 13156 } 13157 13158 case "clusterArn": 13159 if value != nil { 13160 jtv, ok := value.(string) 13161 if !ok { 13162 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13163 } 13164 sv.ClusterArn = ptr.String(jtv) 13165 } 13166 13167 case "createdAt": 13168 if value != nil { 13169 jtv, ok := value.(json.Number) 13170 if !ok { 13171 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13172 } 13173 f64, err := jtv.Float64() 13174 if err != nil { 13175 return err 13176 } 13177 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13178 } 13179 13180 case "createdBy": 13181 if value != nil { 13182 jtv, ok := value.(string) 13183 if !ok { 13184 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13185 } 13186 sv.CreatedBy = ptr.String(jtv) 13187 } 13188 13189 case "deploymentConfiguration": 13190 if err := awsAwsjson11_deserializeDocumentDeploymentConfiguration(&sv.DeploymentConfiguration, value); err != nil { 13191 return err 13192 } 13193 13194 case "deploymentController": 13195 if err := awsAwsjson11_deserializeDocumentDeploymentController(&sv.DeploymentController, value); err != nil { 13196 return err 13197 } 13198 13199 case "deployments": 13200 if err := awsAwsjson11_deserializeDocumentDeployments(&sv.Deployments, value); err != nil { 13201 return err 13202 } 13203 13204 case "desiredCount": 13205 if value != nil { 13206 jtv, ok := value.(json.Number) 13207 if !ok { 13208 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 13209 } 13210 i64, err := jtv.Int64() 13211 if err != nil { 13212 return err 13213 } 13214 sv.DesiredCount = int32(i64) 13215 } 13216 13217 case "enableECSManagedTags": 13218 if value != nil { 13219 jtv, ok := value.(bool) 13220 if !ok { 13221 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 13222 } 13223 sv.EnableECSManagedTags = jtv 13224 } 13225 13226 case "enableExecuteCommand": 13227 if value != nil { 13228 jtv, ok := value.(bool) 13229 if !ok { 13230 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 13231 } 13232 sv.EnableExecuteCommand = jtv 13233 } 13234 13235 case "events": 13236 if err := awsAwsjson11_deserializeDocumentServiceEvents(&sv.Events, value); err != nil { 13237 return err 13238 } 13239 13240 case "healthCheckGracePeriodSeconds": 13241 if value != nil { 13242 jtv, ok := value.(json.Number) 13243 if !ok { 13244 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 13245 } 13246 i64, err := jtv.Int64() 13247 if err != nil { 13248 return err 13249 } 13250 sv.HealthCheckGracePeriodSeconds = ptr.Int32(int32(i64)) 13251 } 13252 13253 case "launchType": 13254 if value != nil { 13255 jtv, ok := value.(string) 13256 if !ok { 13257 return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value) 13258 } 13259 sv.LaunchType = types.LaunchType(jtv) 13260 } 13261 13262 case "loadBalancers": 13263 if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil { 13264 return err 13265 } 13266 13267 case "networkConfiguration": 13268 if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil { 13269 return err 13270 } 13271 13272 case "pendingCount": 13273 if value != nil { 13274 jtv, ok := value.(json.Number) 13275 if !ok { 13276 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 13277 } 13278 i64, err := jtv.Int64() 13279 if err != nil { 13280 return err 13281 } 13282 sv.PendingCount = int32(i64) 13283 } 13284 13285 case "placementConstraints": 13286 if err := awsAwsjson11_deserializeDocumentPlacementConstraints(&sv.PlacementConstraints, value); err != nil { 13287 return err 13288 } 13289 13290 case "placementStrategy": 13291 if err := awsAwsjson11_deserializeDocumentPlacementStrategies(&sv.PlacementStrategy, value); err != nil { 13292 return err 13293 } 13294 13295 case "platformVersion": 13296 if value != nil { 13297 jtv, ok := value.(string) 13298 if !ok { 13299 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13300 } 13301 sv.PlatformVersion = ptr.String(jtv) 13302 } 13303 13304 case "propagateTags": 13305 if value != nil { 13306 jtv, ok := value.(string) 13307 if !ok { 13308 return fmt.Errorf("expected PropagateTags to be of type string, got %T instead", value) 13309 } 13310 sv.PropagateTags = types.PropagateTags(jtv) 13311 } 13312 13313 case "roleArn": 13314 if value != nil { 13315 jtv, ok := value.(string) 13316 if !ok { 13317 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13318 } 13319 sv.RoleArn = ptr.String(jtv) 13320 } 13321 13322 case "runningCount": 13323 if value != nil { 13324 jtv, ok := value.(json.Number) 13325 if !ok { 13326 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 13327 } 13328 i64, err := jtv.Int64() 13329 if err != nil { 13330 return err 13331 } 13332 sv.RunningCount = int32(i64) 13333 } 13334 13335 case "schedulingStrategy": 13336 if value != nil { 13337 jtv, ok := value.(string) 13338 if !ok { 13339 return fmt.Errorf("expected SchedulingStrategy to be of type string, got %T instead", value) 13340 } 13341 sv.SchedulingStrategy = types.SchedulingStrategy(jtv) 13342 } 13343 13344 case "serviceArn": 13345 if value != nil { 13346 jtv, ok := value.(string) 13347 if !ok { 13348 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13349 } 13350 sv.ServiceArn = ptr.String(jtv) 13351 } 13352 13353 case "serviceName": 13354 if value != nil { 13355 jtv, ok := value.(string) 13356 if !ok { 13357 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13358 } 13359 sv.ServiceName = ptr.String(jtv) 13360 } 13361 13362 case "serviceRegistries": 13363 if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil { 13364 return err 13365 } 13366 13367 case "status": 13368 if value != nil { 13369 jtv, ok := value.(string) 13370 if !ok { 13371 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13372 } 13373 sv.Status = ptr.String(jtv) 13374 } 13375 13376 case "tags": 13377 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 13378 return err 13379 } 13380 13381 case "taskDefinition": 13382 if value != nil { 13383 jtv, ok := value.(string) 13384 if !ok { 13385 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13386 } 13387 sv.TaskDefinition = ptr.String(jtv) 13388 } 13389 13390 case "taskSets": 13391 if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil { 13392 return err 13393 } 13394 13395 default: 13396 _, _ = key, value 13397 13398 } 13399 } 13400 *v = sv 13401 return nil 13402} 13403 13404func awsAwsjson11_deserializeDocumentServiceEvent(v **types.ServiceEvent, value interface{}) error { 13405 if v == nil { 13406 return fmt.Errorf("unexpected nil of type %T", v) 13407 } 13408 if value == nil { 13409 return nil 13410 } 13411 13412 shape, ok := value.(map[string]interface{}) 13413 if !ok { 13414 return fmt.Errorf("unexpected JSON type %v", value) 13415 } 13416 13417 var sv *types.ServiceEvent 13418 if *v == nil { 13419 sv = &types.ServiceEvent{} 13420 } else { 13421 sv = *v 13422 } 13423 13424 for key, value := range shape { 13425 switch key { 13426 case "createdAt": 13427 if value != nil { 13428 jtv, ok := value.(json.Number) 13429 if !ok { 13430 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 13431 } 13432 f64, err := jtv.Float64() 13433 if err != nil { 13434 return err 13435 } 13436 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13437 } 13438 13439 case "id": 13440 if value != nil { 13441 jtv, ok := value.(string) 13442 if !ok { 13443 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13444 } 13445 sv.Id = ptr.String(jtv) 13446 } 13447 13448 case "message": 13449 if value != nil { 13450 jtv, ok := value.(string) 13451 if !ok { 13452 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13453 } 13454 sv.Message = ptr.String(jtv) 13455 } 13456 13457 default: 13458 _, _ = key, value 13459 13460 } 13461 } 13462 *v = sv 13463 return nil 13464} 13465 13466func awsAwsjson11_deserializeDocumentServiceEvents(v *[]types.ServiceEvent, value interface{}) error { 13467 if v == nil { 13468 return fmt.Errorf("unexpected nil of type %T", v) 13469 } 13470 if value == nil { 13471 return nil 13472 } 13473 13474 shape, ok := value.([]interface{}) 13475 if !ok { 13476 return fmt.Errorf("unexpected JSON type %v", value) 13477 } 13478 13479 var cv []types.ServiceEvent 13480 if *v == nil { 13481 cv = []types.ServiceEvent{} 13482 } else { 13483 cv = *v 13484 } 13485 13486 for _, value := range shape { 13487 var col types.ServiceEvent 13488 destAddr := &col 13489 if err := awsAwsjson11_deserializeDocumentServiceEvent(&destAddr, value); err != nil { 13490 return err 13491 } 13492 col = *destAddr 13493 cv = append(cv, col) 13494 13495 } 13496 *v = cv 13497 return nil 13498} 13499 13500func awsAwsjson11_deserializeDocumentServiceNotActiveException(v **types.ServiceNotActiveException, value interface{}) error { 13501 if v == nil { 13502 return fmt.Errorf("unexpected nil of type %T", v) 13503 } 13504 if value == nil { 13505 return nil 13506 } 13507 13508 shape, ok := value.(map[string]interface{}) 13509 if !ok { 13510 return fmt.Errorf("unexpected JSON type %v", value) 13511 } 13512 13513 var sv *types.ServiceNotActiveException 13514 if *v == nil { 13515 sv = &types.ServiceNotActiveException{} 13516 } else { 13517 sv = *v 13518 } 13519 13520 for key, value := range shape { 13521 switch key { 13522 case "message": 13523 if value != nil { 13524 jtv, ok := value.(string) 13525 if !ok { 13526 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13527 } 13528 sv.Message = ptr.String(jtv) 13529 } 13530 13531 default: 13532 _, _ = key, value 13533 13534 } 13535 } 13536 *v = sv 13537 return nil 13538} 13539 13540func awsAwsjson11_deserializeDocumentServiceNotFoundException(v **types.ServiceNotFoundException, value interface{}) error { 13541 if v == nil { 13542 return fmt.Errorf("unexpected nil of type %T", v) 13543 } 13544 if value == nil { 13545 return nil 13546 } 13547 13548 shape, ok := value.(map[string]interface{}) 13549 if !ok { 13550 return fmt.Errorf("unexpected JSON type %v", value) 13551 } 13552 13553 var sv *types.ServiceNotFoundException 13554 if *v == nil { 13555 sv = &types.ServiceNotFoundException{} 13556 } else { 13557 sv = *v 13558 } 13559 13560 for key, value := range shape { 13561 switch key { 13562 case "message": 13563 if value != nil { 13564 jtv, ok := value.(string) 13565 if !ok { 13566 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13567 } 13568 sv.Message = ptr.String(jtv) 13569 } 13570 13571 default: 13572 _, _ = key, value 13573 13574 } 13575 } 13576 *v = sv 13577 return nil 13578} 13579 13580func awsAwsjson11_deserializeDocumentServiceRegistries(v *[]types.ServiceRegistry, value interface{}) error { 13581 if v == nil { 13582 return fmt.Errorf("unexpected nil of type %T", v) 13583 } 13584 if value == nil { 13585 return nil 13586 } 13587 13588 shape, ok := value.([]interface{}) 13589 if !ok { 13590 return fmt.Errorf("unexpected JSON type %v", value) 13591 } 13592 13593 var cv []types.ServiceRegistry 13594 if *v == nil { 13595 cv = []types.ServiceRegistry{} 13596 } else { 13597 cv = *v 13598 } 13599 13600 for _, value := range shape { 13601 var col types.ServiceRegistry 13602 destAddr := &col 13603 if err := awsAwsjson11_deserializeDocumentServiceRegistry(&destAddr, value); err != nil { 13604 return err 13605 } 13606 col = *destAddr 13607 cv = append(cv, col) 13608 13609 } 13610 *v = cv 13611 return nil 13612} 13613 13614func awsAwsjson11_deserializeDocumentServiceRegistry(v **types.ServiceRegistry, value interface{}) error { 13615 if v == nil { 13616 return fmt.Errorf("unexpected nil of type %T", v) 13617 } 13618 if value == nil { 13619 return nil 13620 } 13621 13622 shape, ok := value.(map[string]interface{}) 13623 if !ok { 13624 return fmt.Errorf("unexpected JSON type %v", value) 13625 } 13626 13627 var sv *types.ServiceRegistry 13628 if *v == nil { 13629 sv = &types.ServiceRegistry{} 13630 } else { 13631 sv = *v 13632 } 13633 13634 for key, value := range shape { 13635 switch key { 13636 case "containerName": 13637 if value != nil { 13638 jtv, ok := value.(string) 13639 if !ok { 13640 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13641 } 13642 sv.ContainerName = ptr.String(jtv) 13643 } 13644 13645 case "containerPort": 13646 if value != nil { 13647 jtv, ok := value.(json.Number) 13648 if !ok { 13649 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 13650 } 13651 i64, err := jtv.Int64() 13652 if err != nil { 13653 return err 13654 } 13655 sv.ContainerPort = ptr.Int32(int32(i64)) 13656 } 13657 13658 case "port": 13659 if value != nil { 13660 jtv, ok := value.(json.Number) 13661 if !ok { 13662 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 13663 } 13664 i64, err := jtv.Int64() 13665 if err != nil { 13666 return err 13667 } 13668 sv.Port = ptr.Int32(int32(i64)) 13669 } 13670 13671 case "registryArn": 13672 if value != nil { 13673 jtv, ok := value.(string) 13674 if !ok { 13675 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13676 } 13677 sv.RegistryArn = ptr.String(jtv) 13678 } 13679 13680 default: 13681 _, _ = key, value 13682 13683 } 13684 } 13685 *v = sv 13686 return nil 13687} 13688 13689func awsAwsjson11_deserializeDocumentServices(v *[]types.Service, value interface{}) error { 13690 if v == nil { 13691 return fmt.Errorf("unexpected nil of type %T", v) 13692 } 13693 if value == nil { 13694 return nil 13695 } 13696 13697 shape, ok := value.([]interface{}) 13698 if !ok { 13699 return fmt.Errorf("unexpected JSON type %v", value) 13700 } 13701 13702 var cv []types.Service 13703 if *v == nil { 13704 cv = []types.Service{} 13705 } else { 13706 cv = *v 13707 } 13708 13709 for _, value := range shape { 13710 var col types.Service 13711 destAddr := &col 13712 if err := awsAwsjson11_deserializeDocumentService(&destAddr, value); err != nil { 13713 return err 13714 } 13715 col = *destAddr 13716 cv = append(cv, col) 13717 13718 } 13719 *v = cv 13720 return nil 13721} 13722 13723func awsAwsjson11_deserializeDocumentSession(v **types.Session, value interface{}) error { 13724 if v == nil { 13725 return fmt.Errorf("unexpected nil of type %T", v) 13726 } 13727 if value == nil { 13728 return nil 13729 } 13730 13731 shape, ok := value.(map[string]interface{}) 13732 if !ok { 13733 return fmt.Errorf("unexpected JSON type %v", value) 13734 } 13735 13736 var sv *types.Session 13737 if *v == nil { 13738 sv = &types.Session{} 13739 } else { 13740 sv = *v 13741 } 13742 13743 for key, value := range shape { 13744 switch key { 13745 case "sessionId": 13746 if value != nil { 13747 jtv, ok := value.(string) 13748 if !ok { 13749 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13750 } 13751 sv.SessionId = ptr.String(jtv) 13752 } 13753 13754 case "streamUrl": 13755 if value != nil { 13756 jtv, ok := value.(string) 13757 if !ok { 13758 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13759 } 13760 sv.StreamUrl = ptr.String(jtv) 13761 } 13762 13763 case "tokenValue": 13764 if value != nil { 13765 jtv, ok := value.(string) 13766 if !ok { 13767 return fmt.Errorf("expected SensitiveString to be of type string, got %T instead", value) 13768 } 13769 sv.TokenValue = ptr.String(jtv) 13770 } 13771 13772 default: 13773 _, _ = key, value 13774 13775 } 13776 } 13777 *v = sv 13778 return nil 13779} 13780 13781func awsAwsjson11_deserializeDocumentSetting(v **types.Setting, value interface{}) error { 13782 if v == nil { 13783 return fmt.Errorf("unexpected nil of type %T", v) 13784 } 13785 if value == nil { 13786 return nil 13787 } 13788 13789 shape, ok := value.(map[string]interface{}) 13790 if !ok { 13791 return fmt.Errorf("unexpected JSON type %v", value) 13792 } 13793 13794 var sv *types.Setting 13795 if *v == nil { 13796 sv = &types.Setting{} 13797 } else { 13798 sv = *v 13799 } 13800 13801 for key, value := range shape { 13802 switch key { 13803 case "name": 13804 if value != nil { 13805 jtv, ok := value.(string) 13806 if !ok { 13807 return fmt.Errorf("expected SettingName to be of type string, got %T instead", value) 13808 } 13809 sv.Name = types.SettingName(jtv) 13810 } 13811 13812 case "principalArn": 13813 if value != nil { 13814 jtv, ok := value.(string) 13815 if !ok { 13816 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13817 } 13818 sv.PrincipalArn = ptr.String(jtv) 13819 } 13820 13821 case "value": 13822 if value != nil { 13823 jtv, ok := value.(string) 13824 if !ok { 13825 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13826 } 13827 sv.Value = ptr.String(jtv) 13828 } 13829 13830 default: 13831 _, _ = key, value 13832 13833 } 13834 } 13835 *v = sv 13836 return nil 13837} 13838 13839func awsAwsjson11_deserializeDocumentSettings(v *[]types.Setting, value interface{}) error { 13840 if v == nil { 13841 return fmt.Errorf("unexpected nil of type %T", v) 13842 } 13843 if value == nil { 13844 return nil 13845 } 13846 13847 shape, ok := value.([]interface{}) 13848 if !ok { 13849 return fmt.Errorf("unexpected JSON type %v", value) 13850 } 13851 13852 var cv []types.Setting 13853 if *v == nil { 13854 cv = []types.Setting{} 13855 } else { 13856 cv = *v 13857 } 13858 13859 for _, value := range shape { 13860 var col types.Setting 13861 destAddr := &col 13862 if err := awsAwsjson11_deserializeDocumentSetting(&destAddr, value); err != nil { 13863 return err 13864 } 13865 col = *destAddr 13866 cv = append(cv, col) 13867 13868 } 13869 *v = cv 13870 return nil 13871} 13872 13873func awsAwsjson11_deserializeDocumentStatistics(v *[]types.KeyValuePair, value interface{}) error { 13874 if v == nil { 13875 return fmt.Errorf("unexpected nil of type %T", v) 13876 } 13877 if value == nil { 13878 return nil 13879 } 13880 13881 shape, ok := value.([]interface{}) 13882 if !ok { 13883 return fmt.Errorf("unexpected JSON type %v", value) 13884 } 13885 13886 var cv []types.KeyValuePair 13887 if *v == nil { 13888 cv = []types.KeyValuePair{} 13889 } else { 13890 cv = *v 13891 } 13892 13893 for _, value := range shape { 13894 var col types.KeyValuePair 13895 destAddr := &col 13896 if err := awsAwsjson11_deserializeDocumentKeyValuePair(&destAddr, value); err != nil { 13897 return err 13898 } 13899 col = *destAddr 13900 cv = append(cv, col) 13901 13902 } 13903 *v = cv 13904 return nil 13905} 13906 13907func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error { 13908 if v == nil { 13909 return fmt.Errorf("unexpected nil of type %T", v) 13910 } 13911 if value == nil { 13912 return nil 13913 } 13914 13915 shape, ok := value.([]interface{}) 13916 if !ok { 13917 return fmt.Errorf("unexpected JSON type %v", value) 13918 } 13919 13920 var cv []string 13921 if *v == nil { 13922 cv = []string{} 13923 } else { 13924 cv = *v 13925 } 13926 13927 for _, value := range shape { 13928 var col string 13929 if value != nil { 13930 jtv, ok := value.(string) 13931 if !ok { 13932 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13933 } 13934 col = jtv 13935 } 13936 cv = append(cv, col) 13937 13938 } 13939 *v = cv 13940 return nil 13941} 13942 13943func awsAwsjson11_deserializeDocumentStringMap(v *map[string]string, value interface{}) error { 13944 if v == nil { 13945 return fmt.Errorf("unexpected nil of type %T", v) 13946 } 13947 if value == nil { 13948 return nil 13949 } 13950 13951 shape, ok := value.(map[string]interface{}) 13952 if !ok { 13953 return fmt.Errorf("unexpected JSON type %v", value) 13954 } 13955 13956 var mv map[string]string 13957 if *v == nil { 13958 mv = map[string]string{} 13959 } else { 13960 mv = *v 13961 } 13962 13963 for key, value := range shape { 13964 var parsedVal string 13965 if value != nil { 13966 jtv, ok := value.(string) 13967 if !ok { 13968 return fmt.Errorf("expected String to be of type string, got %T instead", value) 13969 } 13970 parsedVal = jtv 13971 } 13972 mv[key] = parsedVal 13973 13974 } 13975 *v = mv 13976 return nil 13977} 13978 13979func awsAwsjson11_deserializeDocumentSystemControl(v **types.SystemControl, value interface{}) error { 13980 if v == nil { 13981 return fmt.Errorf("unexpected nil of type %T", v) 13982 } 13983 if value == nil { 13984 return nil 13985 } 13986 13987 shape, ok := value.(map[string]interface{}) 13988 if !ok { 13989 return fmt.Errorf("unexpected JSON type %v", value) 13990 } 13991 13992 var sv *types.SystemControl 13993 if *v == nil { 13994 sv = &types.SystemControl{} 13995 } else { 13996 sv = *v 13997 } 13998 13999 for key, value := range shape { 14000 switch key { 14001 case "namespace": 14002 if value != nil { 14003 jtv, ok := value.(string) 14004 if !ok { 14005 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14006 } 14007 sv.Namespace = ptr.String(jtv) 14008 } 14009 14010 case "value": 14011 if value != nil { 14012 jtv, ok := value.(string) 14013 if !ok { 14014 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14015 } 14016 sv.Value = ptr.String(jtv) 14017 } 14018 14019 default: 14020 _, _ = key, value 14021 14022 } 14023 } 14024 *v = sv 14025 return nil 14026} 14027 14028func awsAwsjson11_deserializeDocumentSystemControls(v *[]types.SystemControl, value interface{}) error { 14029 if v == nil { 14030 return fmt.Errorf("unexpected nil of type %T", v) 14031 } 14032 if value == nil { 14033 return nil 14034 } 14035 14036 shape, ok := value.([]interface{}) 14037 if !ok { 14038 return fmt.Errorf("unexpected JSON type %v", value) 14039 } 14040 14041 var cv []types.SystemControl 14042 if *v == nil { 14043 cv = []types.SystemControl{} 14044 } else { 14045 cv = *v 14046 } 14047 14048 for _, value := range shape { 14049 var col types.SystemControl 14050 destAddr := &col 14051 if err := awsAwsjson11_deserializeDocumentSystemControl(&destAddr, value); err != nil { 14052 return err 14053 } 14054 col = *destAddr 14055 cv = append(cv, col) 14056 14057 } 14058 *v = cv 14059 return nil 14060} 14061 14062func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 14063 if v == nil { 14064 return fmt.Errorf("unexpected nil of type %T", v) 14065 } 14066 if value == nil { 14067 return nil 14068 } 14069 14070 shape, ok := value.(map[string]interface{}) 14071 if !ok { 14072 return fmt.Errorf("unexpected JSON type %v", value) 14073 } 14074 14075 var sv *types.Tag 14076 if *v == nil { 14077 sv = &types.Tag{} 14078 } else { 14079 sv = *v 14080 } 14081 14082 for key, value := range shape { 14083 switch key { 14084 case "key": 14085 if value != nil { 14086 jtv, ok := value.(string) 14087 if !ok { 14088 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 14089 } 14090 sv.Key = ptr.String(jtv) 14091 } 14092 14093 case "value": 14094 if value != nil { 14095 jtv, ok := value.(string) 14096 if !ok { 14097 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 14098 } 14099 sv.Value = ptr.String(jtv) 14100 } 14101 14102 default: 14103 _, _ = key, value 14104 14105 } 14106 } 14107 *v = sv 14108 return nil 14109} 14110 14111func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 14112 if v == nil { 14113 return fmt.Errorf("unexpected nil of type %T", v) 14114 } 14115 if value == nil { 14116 return nil 14117 } 14118 14119 shape, ok := value.([]interface{}) 14120 if !ok { 14121 return fmt.Errorf("unexpected JSON type %v", value) 14122 } 14123 14124 var cv []types.Tag 14125 if *v == nil { 14126 cv = []types.Tag{} 14127 } else { 14128 cv = *v 14129 } 14130 14131 for _, value := range shape { 14132 var col types.Tag 14133 destAddr := &col 14134 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 14135 return err 14136 } 14137 col = *destAddr 14138 cv = append(cv, col) 14139 14140 } 14141 *v = cv 14142 return nil 14143} 14144 14145func awsAwsjson11_deserializeDocumentTargetNotConnectedException(v **types.TargetNotConnectedException, value interface{}) error { 14146 if v == nil { 14147 return fmt.Errorf("unexpected nil of type %T", v) 14148 } 14149 if value == nil { 14150 return nil 14151 } 14152 14153 shape, ok := value.(map[string]interface{}) 14154 if !ok { 14155 return fmt.Errorf("unexpected JSON type %v", value) 14156 } 14157 14158 var sv *types.TargetNotConnectedException 14159 if *v == nil { 14160 sv = &types.TargetNotConnectedException{} 14161 } else { 14162 sv = *v 14163 } 14164 14165 for key, value := range shape { 14166 switch key { 14167 case "message": 14168 if value != nil { 14169 jtv, ok := value.(string) 14170 if !ok { 14171 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14172 } 14173 sv.Message = ptr.String(jtv) 14174 } 14175 14176 default: 14177 _, _ = key, value 14178 14179 } 14180 } 14181 *v = sv 14182 return nil 14183} 14184 14185func awsAwsjson11_deserializeDocumentTargetNotFoundException(v **types.TargetNotFoundException, value interface{}) error { 14186 if v == nil { 14187 return fmt.Errorf("unexpected nil of type %T", v) 14188 } 14189 if value == nil { 14190 return nil 14191 } 14192 14193 shape, ok := value.(map[string]interface{}) 14194 if !ok { 14195 return fmt.Errorf("unexpected JSON type %v", value) 14196 } 14197 14198 var sv *types.TargetNotFoundException 14199 if *v == nil { 14200 sv = &types.TargetNotFoundException{} 14201 } else { 14202 sv = *v 14203 } 14204 14205 for key, value := range shape { 14206 switch key { 14207 case "message": 14208 if value != nil { 14209 jtv, ok := value.(string) 14210 if !ok { 14211 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14212 } 14213 sv.Message = ptr.String(jtv) 14214 } 14215 14216 default: 14217 _, _ = key, value 14218 14219 } 14220 } 14221 *v = sv 14222 return nil 14223} 14224 14225func awsAwsjson11_deserializeDocumentTask(v **types.Task, value interface{}) error { 14226 if v == nil { 14227 return fmt.Errorf("unexpected nil of type %T", v) 14228 } 14229 if value == nil { 14230 return nil 14231 } 14232 14233 shape, ok := value.(map[string]interface{}) 14234 if !ok { 14235 return fmt.Errorf("unexpected JSON type %v", value) 14236 } 14237 14238 var sv *types.Task 14239 if *v == nil { 14240 sv = &types.Task{} 14241 } else { 14242 sv = *v 14243 } 14244 14245 for key, value := range shape { 14246 switch key { 14247 case "attachments": 14248 if err := awsAwsjson11_deserializeDocumentAttachments(&sv.Attachments, value); err != nil { 14249 return err 14250 } 14251 14252 case "attributes": 14253 if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 14254 return err 14255 } 14256 14257 case "availabilityZone": 14258 if value != nil { 14259 jtv, ok := value.(string) 14260 if !ok { 14261 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14262 } 14263 sv.AvailabilityZone = ptr.String(jtv) 14264 } 14265 14266 case "capacityProviderName": 14267 if value != nil { 14268 jtv, ok := value.(string) 14269 if !ok { 14270 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14271 } 14272 sv.CapacityProviderName = ptr.String(jtv) 14273 } 14274 14275 case "clusterArn": 14276 if value != nil { 14277 jtv, ok := value.(string) 14278 if !ok { 14279 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14280 } 14281 sv.ClusterArn = ptr.String(jtv) 14282 } 14283 14284 case "connectivity": 14285 if value != nil { 14286 jtv, ok := value.(string) 14287 if !ok { 14288 return fmt.Errorf("expected Connectivity to be of type string, got %T instead", value) 14289 } 14290 sv.Connectivity = types.Connectivity(jtv) 14291 } 14292 14293 case "connectivityAt": 14294 if value != nil { 14295 jtv, ok := value.(json.Number) 14296 if !ok { 14297 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14298 } 14299 f64, err := jtv.Float64() 14300 if err != nil { 14301 return err 14302 } 14303 sv.ConnectivityAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14304 } 14305 14306 case "containerInstanceArn": 14307 if value != nil { 14308 jtv, ok := value.(string) 14309 if !ok { 14310 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14311 } 14312 sv.ContainerInstanceArn = ptr.String(jtv) 14313 } 14314 14315 case "containers": 14316 if err := awsAwsjson11_deserializeDocumentContainers(&sv.Containers, value); err != nil { 14317 return err 14318 } 14319 14320 case "cpu": 14321 if value != nil { 14322 jtv, ok := value.(string) 14323 if !ok { 14324 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14325 } 14326 sv.Cpu = ptr.String(jtv) 14327 } 14328 14329 case "createdAt": 14330 if value != nil { 14331 jtv, ok := value.(json.Number) 14332 if !ok { 14333 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14334 } 14335 f64, err := jtv.Float64() 14336 if err != nil { 14337 return err 14338 } 14339 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14340 } 14341 14342 case "desiredStatus": 14343 if value != nil { 14344 jtv, ok := value.(string) 14345 if !ok { 14346 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14347 } 14348 sv.DesiredStatus = ptr.String(jtv) 14349 } 14350 14351 case "enableExecuteCommand": 14352 if value != nil { 14353 jtv, ok := value.(bool) 14354 if !ok { 14355 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 14356 } 14357 sv.EnableExecuteCommand = jtv 14358 } 14359 14360 case "ephemeralStorage": 14361 if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil { 14362 return err 14363 } 14364 14365 case "executionStoppedAt": 14366 if value != nil { 14367 jtv, ok := value.(json.Number) 14368 if !ok { 14369 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14370 } 14371 f64, err := jtv.Float64() 14372 if err != nil { 14373 return err 14374 } 14375 sv.ExecutionStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14376 } 14377 14378 case "group": 14379 if value != nil { 14380 jtv, ok := value.(string) 14381 if !ok { 14382 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14383 } 14384 sv.Group = ptr.String(jtv) 14385 } 14386 14387 case "healthStatus": 14388 if value != nil { 14389 jtv, ok := value.(string) 14390 if !ok { 14391 return fmt.Errorf("expected HealthStatus to be of type string, got %T instead", value) 14392 } 14393 sv.HealthStatus = types.HealthStatus(jtv) 14394 } 14395 14396 case "inferenceAccelerators": 14397 if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil { 14398 return err 14399 } 14400 14401 case "lastStatus": 14402 if value != nil { 14403 jtv, ok := value.(string) 14404 if !ok { 14405 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14406 } 14407 sv.LastStatus = ptr.String(jtv) 14408 } 14409 14410 case "launchType": 14411 if value != nil { 14412 jtv, ok := value.(string) 14413 if !ok { 14414 return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value) 14415 } 14416 sv.LaunchType = types.LaunchType(jtv) 14417 } 14418 14419 case "memory": 14420 if value != nil { 14421 jtv, ok := value.(string) 14422 if !ok { 14423 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14424 } 14425 sv.Memory = ptr.String(jtv) 14426 } 14427 14428 case "overrides": 14429 if err := awsAwsjson11_deserializeDocumentTaskOverride(&sv.Overrides, value); err != nil { 14430 return err 14431 } 14432 14433 case "platformVersion": 14434 if value != nil { 14435 jtv, ok := value.(string) 14436 if !ok { 14437 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14438 } 14439 sv.PlatformVersion = ptr.String(jtv) 14440 } 14441 14442 case "pullStartedAt": 14443 if value != nil { 14444 jtv, ok := value.(json.Number) 14445 if !ok { 14446 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14447 } 14448 f64, err := jtv.Float64() 14449 if err != nil { 14450 return err 14451 } 14452 sv.PullStartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14453 } 14454 14455 case "pullStoppedAt": 14456 if value != nil { 14457 jtv, ok := value.(json.Number) 14458 if !ok { 14459 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14460 } 14461 f64, err := jtv.Float64() 14462 if err != nil { 14463 return err 14464 } 14465 sv.PullStoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14466 } 14467 14468 case "startedAt": 14469 if value != nil { 14470 jtv, ok := value.(json.Number) 14471 if !ok { 14472 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14473 } 14474 f64, err := jtv.Float64() 14475 if err != nil { 14476 return err 14477 } 14478 sv.StartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14479 } 14480 14481 case "startedBy": 14482 if value != nil { 14483 jtv, ok := value.(string) 14484 if !ok { 14485 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14486 } 14487 sv.StartedBy = ptr.String(jtv) 14488 } 14489 14490 case "stopCode": 14491 if value != nil { 14492 jtv, ok := value.(string) 14493 if !ok { 14494 return fmt.Errorf("expected TaskStopCode to be of type string, got %T instead", value) 14495 } 14496 sv.StopCode = types.TaskStopCode(jtv) 14497 } 14498 14499 case "stoppedAt": 14500 if value != nil { 14501 jtv, ok := value.(json.Number) 14502 if !ok { 14503 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14504 } 14505 f64, err := jtv.Float64() 14506 if err != nil { 14507 return err 14508 } 14509 sv.StoppedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14510 } 14511 14512 case "stoppedReason": 14513 if value != nil { 14514 jtv, ok := value.(string) 14515 if !ok { 14516 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14517 } 14518 sv.StoppedReason = ptr.String(jtv) 14519 } 14520 14521 case "stoppingAt": 14522 if value != nil { 14523 jtv, ok := value.(json.Number) 14524 if !ok { 14525 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14526 } 14527 f64, err := jtv.Float64() 14528 if err != nil { 14529 return err 14530 } 14531 sv.StoppingAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14532 } 14533 14534 case "tags": 14535 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 14536 return err 14537 } 14538 14539 case "taskArn": 14540 if value != nil { 14541 jtv, ok := value.(string) 14542 if !ok { 14543 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14544 } 14545 sv.TaskArn = ptr.String(jtv) 14546 } 14547 14548 case "taskDefinitionArn": 14549 if value != nil { 14550 jtv, ok := value.(string) 14551 if !ok { 14552 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14553 } 14554 sv.TaskDefinitionArn = ptr.String(jtv) 14555 } 14556 14557 case "version": 14558 if value != nil { 14559 jtv, ok := value.(json.Number) 14560 if !ok { 14561 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 14562 } 14563 i64, err := jtv.Int64() 14564 if err != nil { 14565 return err 14566 } 14567 sv.Version = i64 14568 } 14569 14570 default: 14571 _, _ = key, value 14572 14573 } 14574 } 14575 *v = sv 14576 return nil 14577} 14578 14579func awsAwsjson11_deserializeDocumentTaskDefinition(v **types.TaskDefinition, value interface{}) error { 14580 if v == nil { 14581 return fmt.Errorf("unexpected nil of type %T", v) 14582 } 14583 if value == nil { 14584 return nil 14585 } 14586 14587 shape, ok := value.(map[string]interface{}) 14588 if !ok { 14589 return fmt.Errorf("unexpected JSON type %v", value) 14590 } 14591 14592 var sv *types.TaskDefinition 14593 if *v == nil { 14594 sv = &types.TaskDefinition{} 14595 } else { 14596 sv = *v 14597 } 14598 14599 for key, value := range shape { 14600 switch key { 14601 case "compatibilities": 14602 if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.Compatibilities, value); err != nil { 14603 return err 14604 } 14605 14606 case "containerDefinitions": 14607 if err := awsAwsjson11_deserializeDocumentContainerDefinitions(&sv.ContainerDefinitions, value); err != nil { 14608 return err 14609 } 14610 14611 case "cpu": 14612 if value != nil { 14613 jtv, ok := value.(string) 14614 if !ok { 14615 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14616 } 14617 sv.Cpu = ptr.String(jtv) 14618 } 14619 14620 case "deregisteredAt": 14621 if value != nil { 14622 jtv, ok := value.(json.Number) 14623 if !ok { 14624 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14625 } 14626 f64, err := jtv.Float64() 14627 if err != nil { 14628 return err 14629 } 14630 sv.DeregisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14631 } 14632 14633 case "ephemeralStorage": 14634 if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil { 14635 return err 14636 } 14637 14638 case "executionRoleArn": 14639 if value != nil { 14640 jtv, ok := value.(string) 14641 if !ok { 14642 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14643 } 14644 sv.ExecutionRoleArn = ptr.String(jtv) 14645 } 14646 14647 case "family": 14648 if value != nil { 14649 jtv, ok := value.(string) 14650 if !ok { 14651 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14652 } 14653 sv.Family = ptr.String(jtv) 14654 } 14655 14656 case "inferenceAccelerators": 14657 if err := awsAwsjson11_deserializeDocumentInferenceAccelerators(&sv.InferenceAccelerators, value); err != nil { 14658 return err 14659 } 14660 14661 case "ipcMode": 14662 if value != nil { 14663 jtv, ok := value.(string) 14664 if !ok { 14665 return fmt.Errorf("expected IpcMode to be of type string, got %T instead", value) 14666 } 14667 sv.IpcMode = types.IpcMode(jtv) 14668 } 14669 14670 case "memory": 14671 if value != nil { 14672 jtv, ok := value.(string) 14673 if !ok { 14674 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14675 } 14676 sv.Memory = ptr.String(jtv) 14677 } 14678 14679 case "networkMode": 14680 if value != nil { 14681 jtv, ok := value.(string) 14682 if !ok { 14683 return fmt.Errorf("expected NetworkMode to be of type string, got %T instead", value) 14684 } 14685 sv.NetworkMode = types.NetworkMode(jtv) 14686 } 14687 14688 case "pidMode": 14689 if value != nil { 14690 jtv, ok := value.(string) 14691 if !ok { 14692 return fmt.Errorf("expected PidMode to be of type string, got %T instead", value) 14693 } 14694 sv.PidMode = types.PidMode(jtv) 14695 } 14696 14697 case "placementConstraints": 14698 if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(&sv.PlacementConstraints, value); err != nil { 14699 return err 14700 } 14701 14702 case "proxyConfiguration": 14703 if err := awsAwsjson11_deserializeDocumentProxyConfiguration(&sv.ProxyConfiguration, value); err != nil { 14704 return err 14705 } 14706 14707 case "registeredAt": 14708 if value != nil { 14709 jtv, ok := value.(json.Number) 14710 if !ok { 14711 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 14712 } 14713 f64, err := jtv.Float64() 14714 if err != nil { 14715 return err 14716 } 14717 sv.RegisteredAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14718 } 14719 14720 case "registeredBy": 14721 if value != nil { 14722 jtv, ok := value.(string) 14723 if !ok { 14724 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14725 } 14726 sv.RegisteredBy = ptr.String(jtv) 14727 } 14728 14729 case "requiresAttributes": 14730 if err := awsAwsjson11_deserializeDocumentRequiresAttributes(&sv.RequiresAttributes, value); err != nil { 14731 return err 14732 } 14733 14734 case "requiresCompatibilities": 14735 if err := awsAwsjson11_deserializeDocumentCompatibilityList(&sv.RequiresCompatibilities, value); err != nil { 14736 return err 14737 } 14738 14739 case "revision": 14740 if value != nil { 14741 jtv, ok := value.(json.Number) 14742 if !ok { 14743 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 14744 } 14745 i64, err := jtv.Int64() 14746 if err != nil { 14747 return err 14748 } 14749 sv.Revision = int32(i64) 14750 } 14751 14752 case "status": 14753 if value != nil { 14754 jtv, ok := value.(string) 14755 if !ok { 14756 return fmt.Errorf("expected TaskDefinitionStatus to be of type string, got %T instead", value) 14757 } 14758 sv.Status = types.TaskDefinitionStatus(jtv) 14759 } 14760 14761 case "taskDefinitionArn": 14762 if value != nil { 14763 jtv, ok := value.(string) 14764 if !ok { 14765 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14766 } 14767 sv.TaskDefinitionArn = ptr.String(jtv) 14768 } 14769 14770 case "taskRoleArn": 14771 if value != nil { 14772 jtv, ok := value.(string) 14773 if !ok { 14774 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14775 } 14776 sv.TaskRoleArn = ptr.String(jtv) 14777 } 14778 14779 case "volumes": 14780 if err := awsAwsjson11_deserializeDocumentVolumeList(&sv.Volumes, value); err != nil { 14781 return err 14782 } 14783 14784 default: 14785 _, _ = key, value 14786 14787 } 14788 } 14789 *v = sv 14790 return nil 14791} 14792 14793func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(v **types.TaskDefinitionPlacementConstraint, value interface{}) error { 14794 if v == nil { 14795 return fmt.Errorf("unexpected nil of type %T", v) 14796 } 14797 if value == nil { 14798 return nil 14799 } 14800 14801 shape, ok := value.(map[string]interface{}) 14802 if !ok { 14803 return fmt.Errorf("unexpected JSON type %v", value) 14804 } 14805 14806 var sv *types.TaskDefinitionPlacementConstraint 14807 if *v == nil { 14808 sv = &types.TaskDefinitionPlacementConstraint{} 14809 } else { 14810 sv = *v 14811 } 14812 14813 for key, value := range shape { 14814 switch key { 14815 case "expression": 14816 if value != nil { 14817 jtv, ok := value.(string) 14818 if !ok { 14819 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14820 } 14821 sv.Expression = ptr.String(jtv) 14822 } 14823 14824 case "type": 14825 if value != nil { 14826 jtv, ok := value.(string) 14827 if !ok { 14828 return fmt.Errorf("expected TaskDefinitionPlacementConstraintType to be of type string, got %T instead", value) 14829 } 14830 sv.Type = types.TaskDefinitionPlacementConstraintType(jtv) 14831 } 14832 14833 default: 14834 _, _ = key, value 14835 14836 } 14837 } 14838 *v = sv 14839 return nil 14840} 14841 14842func awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraints(v *[]types.TaskDefinitionPlacementConstraint, value interface{}) error { 14843 if v == nil { 14844 return fmt.Errorf("unexpected nil of type %T", v) 14845 } 14846 if value == nil { 14847 return nil 14848 } 14849 14850 shape, ok := value.([]interface{}) 14851 if !ok { 14852 return fmt.Errorf("unexpected JSON type %v", value) 14853 } 14854 14855 var cv []types.TaskDefinitionPlacementConstraint 14856 if *v == nil { 14857 cv = []types.TaskDefinitionPlacementConstraint{} 14858 } else { 14859 cv = *v 14860 } 14861 14862 for _, value := range shape { 14863 var col types.TaskDefinitionPlacementConstraint 14864 destAddr := &col 14865 if err := awsAwsjson11_deserializeDocumentTaskDefinitionPlacementConstraint(&destAddr, value); err != nil { 14866 return err 14867 } 14868 col = *destAddr 14869 cv = append(cv, col) 14870 14871 } 14872 *v = cv 14873 return nil 14874} 14875 14876func awsAwsjson11_deserializeDocumentTaskOverride(v **types.TaskOverride, value interface{}) error { 14877 if v == nil { 14878 return fmt.Errorf("unexpected nil of type %T", v) 14879 } 14880 if value == nil { 14881 return nil 14882 } 14883 14884 shape, ok := value.(map[string]interface{}) 14885 if !ok { 14886 return fmt.Errorf("unexpected JSON type %v", value) 14887 } 14888 14889 var sv *types.TaskOverride 14890 if *v == nil { 14891 sv = &types.TaskOverride{} 14892 } else { 14893 sv = *v 14894 } 14895 14896 for key, value := range shape { 14897 switch key { 14898 case "containerOverrides": 14899 if err := awsAwsjson11_deserializeDocumentContainerOverrides(&sv.ContainerOverrides, value); err != nil { 14900 return err 14901 } 14902 14903 case "cpu": 14904 if value != nil { 14905 jtv, ok := value.(string) 14906 if !ok { 14907 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14908 } 14909 sv.Cpu = ptr.String(jtv) 14910 } 14911 14912 case "ephemeralStorage": 14913 if err := awsAwsjson11_deserializeDocumentEphemeralStorage(&sv.EphemeralStorage, value); err != nil { 14914 return err 14915 } 14916 14917 case "executionRoleArn": 14918 if value != nil { 14919 jtv, ok := value.(string) 14920 if !ok { 14921 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14922 } 14923 sv.ExecutionRoleArn = ptr.String(jtv) 14924 } 14925 14926 case "inferenceAcceleratorOverrides": 14927 if err := awsAwsjson11_deserializeDocumentInferenceAcceleratorOverrides(&sv.InferenceAcceleratorOverrides, value); err != nil { 14928 return err 14929 } 14930 14931 case "memory": 14932 if value != nil { 14933 jtv, ok := value.(string) 14934 if !ok { 14935 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14936 } 14937 sv.Memory = ptr.String(jtv) 14938 } 14939 14940 case "taskRoleArn": 14941 if value != nil { 14942 jtv, ok := value.(string) 14943 if !ok { 14944 return fmt.Errorf("expected String to be of type string, got %T instead", value) 14945 } 14946 sv.TaskRoleArn = ptr.String(jtv) 14947 } 14948 14949 default: 14950 _, _ = key, value 14951 14952 } 14953 } 14954 *v = sv 14955 return nil 14956} 14957 14958func awsAwsjson11_deserializeDocumentTasks(v *[]types.Task, value interface{}) error { 14959 if v == nil { 14960 return fmt.Errorf("unexpected nil of type %T", v) 14961 } 14962 if value == nil { 14963 return nil 14964 } 14965 14966 shape, ok := value.([]interface{}) 14967 if !ok { 14968 return fmt.Errorf("unexpected JSON type %v", value) 14969 } 14970 14971 var cv []types.Task 14972 if *v == nil { 14973 cv = []types.Task{} 14974 } else { 14975 cv = *v 14976 } 14977 14978 for _, value := range shape { 14979 var col types.Task 14980 destAddr := &col 14981 if err := awsAwsjson11_deserializeDocumentTask(&destAddr, value); err != nil { 14982 return err 14983 } 14984 col = *destAddr 14985 cv = append(cv, col) 14986 14987 } 14988 *v = cv 14989 return nil 14990} 14991 14992func awsAwsjson11_deserializeDocumentTaskSet(v **types.TaskSet, value interface{}) error { 14993 if v == nil { 14994 return fmt.Errorf("unexpected nil of type %T", v) 14995 } 14996 if value == nil { 14997 return nil 14998 } 14999 15000 shape, ok := value.(map[string]interface{}) 15001 if !ok { 15002 return fmt.Errorf("unexpected JSON type %v", value) 15003 } 15004 15005 var sv *types.TaskSet 15006 if *v == nil { 15007 sv = &types.TaskSet{} 15008 } else { 15009 sv = *v 15010 } 15011 15012 for key, value := range shape { 15013 switch key { 15014 case "capacityProviderStrategy": 15015 if err := awsAwsjson11_deserializeDocumentCapacityProviderStrategy(&sv.CapacityProviderStrategy, value); err != nil { 15016 return err 15017 } 15018 15019 case "clusterArn": 15020 if value != nil { 15021 jtv, ok := value.(string) 15022 if !ok { 15023 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15024 } 15025 sv.ClusterArn = ptr.String(jtv) 15026 } 15027 15028 case "computedDesiredCount": 15029 if value != nil { 15030 jtv, ok := value.(json.Number) 15031 if !ok { 15032 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15033 } 15034 i64, err := jtv.Int64() 15035 if err != nil { 15036 return err 15037 } 15038 sv.ComputedDesiredCount = int32(i64) 15039 } 15040 15041 case "createdAt": 15042 if value != nil { 15043 jtv, ok := value.(json.Number) 15044 if !ok { 15045 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 15046 } 15047 f64, err := jtv.Float64() 15048 if err != nil { 15049 return err 15050 } 15051 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15052 } 15053 15054 case "externalId": 15055 if value != nil { 15056 jtv, ok := value.(string) 15057 if !ok { 15058 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15059 } 15060 sv.ExternalId = ptr.String(jtv) 15061 } 15062 15063 case "id": 15064 if value != nil { 15065 jtv, ok := value.(string) 15066 if !ok { 15067 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15068 } 15069 sv.Id = ptr.String(jtv) 15070 } 15071 15072 case "launchType": 15073 if value != nil { 15074 jtv, ok := value.(string) 15075 if !ok { 15076 return fmt.Errorf("expected LaunchType to be of type string, got %T instead", value) 15077 } 15078 sv.LaunchType = types.LaunchType(jtv) 15079 } 15080 15081 case "loadBalancers": 15082 if err := awsAwsjson11_deserializeDocumentLoadBalancers(&sv.LoadBalancers, value); err != nil { 15083 return err 15084 } 15085 15086 case "networkConfiguration": 15087 if err := awsAwsjson11_deserializeDocumentNetworkConfiguration(&sv.NetworkConfiguration, value); err != nil { 15088 return err 15089 } 15090 15091 case "pendingCount": 15092 if value != nil { 15093 jtv, ok := value.(json.Number) 15094 if !ok { 15095 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15096 } 15097 i64, err := jtv.Int64() 15098 if err != nil { 15099 return err 15100 } 15101 sv.PendingCount = int32(i64) 15102 } 15103 15104 case "platformVersion": 15105 if value != nil { 15106 jtv, ok := value.(string) 15107 if !ok { 15108 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15109 } 15110 sv.PlatformVersion = ptr.String(jtv) 15111 } 15112 15113 case "runningCount": 15114 if value != nil { 15115 jtv, ok := value.(json.Number) 15116 if !ok { 15117 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15118 } 15119 i64, err := jtv.Int64() 15120 if err != nil { 15121 return err 15122 } 15123 sv.RunningCount = int32(i64) 15124 } 15125 15126 case "scale": 15127 if err := awsAwsjson11_deserializeDocumentScale(&sv.Scale, value); err != nil { 15128 return err 15129 } 15130 15131 case "serviceArn": 15132 if value != nil { 15133 jtv, ok := value.(string) 15134 if !ok { 15135 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15136 } 15137 sv.ServiceArn = ptr.String(jtv) 15138 } 15139 15140 case "serviceRegistries": 15141 if err := awsAwsjson11_deserializeDocumentServiceRegistries(&sv.ServiceRegistries, value); err != nil { 15142 return err 15143 } 15144 15145 case "stabilityStatus": 15146 if value != nil { 15147 jtv, ok := value.(string) 15148 if !ok { 15149 return fmt.Errorf("expected StabilityStatus to be of type string, got %T instead", value) 15150 } 15151 sv.StabilityStatus = types.StabilityStatus(jtv) 15152 } 15153 15154 case "stabilityStatusAt": 15155 if value != nil { 15156 jtv, ok := value.(json.Number) 15157 if !ok { 15158 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 15159 } 15160 f64, err := jtv.Float64() 15161 if err != nil { 15162 return err 15163 } 15164 sv.StabilityStatusAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15165 } 15166 15167 case "startedBy": 15168 if value != nil { 15169 jtv, ok := value.(string) 15170 if !ok { 15171 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15172 } 15173 sv.StartedBy = ptr.String(jtv) 15174 } 15175 15176 case "status": 15177 if value != nil { 15178 jtv, ok := value.(string) 15179 if !ok { 15180 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15181 } 15182 sv.Status = ptr.String(jtv) 15183 } 15184 15185 case "tags": 15186 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 15187 return err 15188 } 15189 15190 case "taskDefinition": 15191 if value != nil { 15192 jtv, ok := value.(string) 15193 if !ok { 15194 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15195 } 15196 sv.TaskDefinition = ptr.String(jtv) 15197 } 15198 15199 case "taskSetArn": 15200 if value != nil { 15201 jtv, ok := value.(string) 15202 if !ok { 15203 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15204 } 15205 sv.TaskSetArn = ptr.String(jtv) 15206 } 15207 15208 case "updatedAt": 15209 if value != nil { 15210 jtv, ok := value.(json.Number) 15211 if !ok { 15212 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 15213 } 15214 f64, err := jtv.Float64() 15215 if err != nil { 15216 return err 15217 } 15218 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 15219 } 15220 15221 default: 15222 _, _ = key, value 15223 15224 } 15225 } 15226 *v = sv 15227 return nil 15228} 15229 15230func awsAwsjson11_deserializeDocumentTaskSetNotFoundException(v **types.TaskSetNotFoundException, value interface{}) error { 15231 if v == nil { 15232 return fmt.Errorf("unexpected nil of type %T", v) 15233 } 15234 if value == nil { 15235 return nil 15236 } 15237 15238 shape, ok := value.(map[string]interface{}) 15239 if !ok { 15240 return fmt.Errorf("unexpected JSON type %v", value) 15241 } 15242 15243 var sv *types.TaskSetNotFoundException 15244 if *v == nil { 15245 sv = &types.TaskSetNotFoundException{} 15246 } else { 15247 sv = *v 15248 } 15249 15250 for key, value := range shape { 15251 switch key { 15252 case "message": 15253 if value != nil { 15254 jtv, ok := value.(string) 15255 if !ok { 15256 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15257 } 15258 sv.Message = ptr.String(jtv) 15259 } 15260 15261 default: 15262 _, _ = key, value 15263 15264 } 15265 } 15266 *v = sv 15267 return nil 15268} 15269 15270func awsAwsjson11_deserializeDocumentTaskSets(v *[]types.TaskSet, value interface{}) error { 15271 if v == nil { 15272 return fmt.Errorf("unexpected nil of type %T", v) 15273 } 15274 if value == nil { 15275 return nil 15276 } 15277 15278 shape, ok := value.([]interface{}) 15279 if !ok { 15280 return fmt.Errorf("unexpected JSON type %v", value) 15281 } 15282 15283 var cv []types.TaskSet 15284 if *v == nil { 15285 cv = []types.TaskSet{} 15286 } else { 15287 cv = *v 15288 } 15289 15290 for _, value := range shape { 15291 var col types.TaskSet 15292 destAddr := &col 15293 if err := awsAwsjson11_deserializeDocumentTaskSet(&destAddr, value); err != nil { 15294 return err 15295 } 15296 col = *destAddr 15297 cv = append(cv, col) 15298 15299 } 15300 *v = cv 15301 return nil 15302} 15303 15304func awsAwsjson11_deserializeDocumentTmpfs(v **types.Tmpfs, value interface{}) error { 15305 if v == nil { 15306 return fmt.Errorf("unexpected nil of type %T", v) 15307 } 15308 if value == nil { 15309 return nil 15310 } 15311 15312 shape, ok := value.(map[string]interface{}) 15313 if !ok { 15314 return fmt.Errorf("unexpected JSON type %v", value) 15315 } 15316 15317 var sv *types.Tmpfs 15318 if *v == nil { 15319 sv = &types.Tmpfs{} 15320 } else { 15321 sv = *v 15322 } 15323 15324 for key, value := range shape { 15325 switch key { 15326 case "containerPath": 15327 if value != nil { 15328 jtv, ok := value.(string) 15329 if !ok { 15330 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15331 } 15332 sv.ContainerPath = ptr.String(jtv) 15333 } 15334 15335 case "mountOptions": 15336 if err := awsAwsjson11_deserializeDocumentStringList(&sv.MountOptions, value); err != nil { 15337 return err 15338 } 15339 15340 case "size": 15341 if value != nil { 15342 jtv, ok := value.(json.Number) 15343 if !ok { 15344 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15345 } 15346 i64, err := jtv.Int64() 15347 if err != nil { 15348 return err 15349 } 15350 sv.Size = int32(i64) 15351 } 15352 15353 default: 15354 _, _ = key, value 15355 15356 } 15357 } 15358 *v = sv 15359 return nil 15360} 15361 15362func awsAwsjson11_deserializeDocumentTmpfsList(v *[]types.Tmpfs, value interface{}) error { 15363 if v == nil { 15364 return fmt.Errorf("unexpected nil of type %T", v) 15365 } 15366 if value == nil { 15367 return nil 15368 } 15369 15370 shape, ok := value.([]interface{}) 15371 if !ok { 15372 return fmt.Errorf("unexpected JSON type %v", value) 15373 } 15374 15375 var cv []types.Tmpfs 15376 if *v == nil { 15377 cv = []types.Tmpfs{} 15378 } else { 15379 cv = *v 15380 } 15381 15382 for _, value := range shape { 15383 var col types.Tmpfs 15384 destAddr := &col 15385 if err := awsAwsjson11_deserializeDocumentTmpfs(&destAddr, value); err != nil { 15386 return err 15387 } 15388 col = *destAddr 15389 cv = append(cv, col) 15390 15391 } 15392 *v = cv 15393 return nil 15394} 15395 15396func awsAwsjson11_deserializeDocumentUlimit(v **types.Ulimit, value interface{}) error { 15397 if v == nil { 15398 return fmt.Errorf("unexpected nil of type %T", v) 15399 } 15400 if value == nil { 15401 return nil 15402 } 15403 15404 shape, ok := value.(map[string]interface{}) 15405 if !ok { 15406 return fmt.Errorf("unexpected JSON type %v", value) 15407 } 15408 15409 var sv *types.Ulimit 15410 if *v == nil { 15411 sv = &types.Ulimit{} 15412 } else { 15413 sv = *v 15414 } 15415 15416 for key, value := range shape { 15417 switch key { 15418 case "hardLimit": 15419 if value != nil { 15420 jtv, ok := value.(json.Number) 15421 if !ok { 15422 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15423 } 15424 i64, err := jtv.Int64() 15425 if err != nil { 15426 return err 15427 } 15428 sv.HardLimit = int32(i64) 15429 } 15430 15431 case "name": 15432 if value != nil { 15433 jtv, ok := value.(string) 15434 if !ok { 15435 return fmt.Errorf("expected UlimitName to be of type string, got %T instead", value) 15436 } 15437 sv.Name = types.UlimitName(jtv) 15438 } 15439 15440 case "softLimit": 15441 if value != nil { 15442 jtv, ok := value.(json.Number) 15443 if !ok { 15444 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 15445 } 15446 i64, err := jtv.Int64() 15447 if err != nil { 15448 return err 15449 } 15450 sv.SoftLimit = int32(i64) 15451 } 15452 15453 default: 15454 _, _ = key, value 15455 15456 } 15457 } 15458 *v = sv 15459 return nil 15460} 15461 15462func awsAwsjson11_deserializeDocumentUlimitList(v *[]types.Ulimit, value interface{}) error { 15463 if v == nil { 15464 return fmt.Errorf("unexpected nil of type %T", v) 15465 } 15466 if value == nil { 15467 return nil 15468 } 15469 15470 shape, ok := value.([]interface{}) 15471 if !ok { 15472 return fmt.Errorf("unexpected JSON type %v", value) 15473 } 15474 15475 var cv []types.Ulimit 15476 if *v == nil { 15477 cv = []types.Ulimit{} 15478 } else { 15479 cv = *v 15480 } 15481 15482 for _, value := range shape { 15483 var col types.Ulimit 15484 destAddr := &col 15485 if err := awsAwsjson11_deserializeDocumentUlimit(&destAddr, value); err != nil { 15486 return err 15487 } 15488 col = *destAddr 15489 cv = append(cv, col) 15490 15491 } 15492 *v = cv 15493 return nil 15494} 15495 15496func awsAwsjson11_deserializeDocumentUnsupportedFeatureException(v **types.UnsupportedFeatureException, value interface{}) error { 15497 if v == nil { 15498 return fmt.Errorf("unexpected nil of type %T", v) 15499 } 15500 if value == nil { 15501 return nil 15502 } 15503 15504 shape, ok := value.(map[string]interface{}) 15505 if !ok { 15506 return fmt.Errorf("unexpected JSON type %v", value) 15507 } 15508 15509 var sv *types.UnsupportedFeatureException 15510 if *v == nil { 15511 sv = &types.UnsupportedFeatureException{} 15512 } else { 15513 sv = *v 15514 } 15515 15516 for key, value := range shape { 15517 switch key { 15518 case "message": 15519 if value != nil { 15520 jtv, ok := value.(string) 15521 if !ok { 15522 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15523 } 15524 sv.Message = ptr.String(jtv) 15525 } 15526 15527 default: 15528 _, _ = key, value 15529 15530 } 15531 } 15532 *v = sv 15533 return nil 15534} 15535 15536func awsAwsjson11_deserializeDocumentUpdateInProgressException(v **types.UpdateInProgressException, value interface{}) error { 15537 if v == nil { 15538 return fmt.Errorf("unexpected nil of type %T", v) 15539 } 15540 if value == nil { 15541 return nil 15542 } 15543 15544 shape, ok := value.(map[string]interface{}) 15545 if !ok { 15546 return fmt.Errorf("unexpected JSON type %v", value) 15547 } 15548 15549 var sv *types.UpdateInProgressException 15550 if *v == nil { 15551 sv = &types.UpdateInProgressException{} 15552 } else { 15553 sv = *v 15554 } 15555 15556 for key, value := range shape { 15557 switch key { 15558 case "message": 15559 if value != nil { 15560 jtv, ok := value.(string) 15561 if !ok { 15562 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15563 } 15564 sv.Message = ptr.String(jtv) 15565 } 15566 15567 default: 15568 _, _ = key, value 15569 15570 } 15571 } 15572 *v = sv 15573 return nil 15574} 15575 15576func awsAwsjson11_deserializeDocumentVersionInfo(v **types.VersionInfo, value interface{}) error { 15577 if v == nil { 15578 return fmt.Errorf("unexpected nil of type %T", v) 15579 } 15580 if value == nil { 15581 return nil 15582 } 15583 15584 shape, ok := value.(map[string]interface{}) 15585 if !ok { 15586 return fmt.Errorf("unexpected JSON type %v", value) 15587 } 15588 15589 var sv *types.VersionInfo 15590 if *v == nil { 15591 sv = &types.VersionInfo{} 15592 } else { 15593 sv = *v 15594 } 15595 15596 for key, value := range shape { 15597 switch key { 15598 case "agentHash": 15599 if value != nil { 15600 jtv, ok := value.(string) 15601 if !ok { 15602 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15603 } 15604 sv.AgentHash = ptr.String(jtv) 15605 } 15606 15607 case "agentVersion": 15608 if value != nil { 15609 jtv, ok := value.(string) 15610 if !ok { 15611 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15612 } 15613 sv.AgentVersion = ptr.String(jtv) 15614 } 15615 15616 case "dockerVersion": 15617 if value != nil { 15618 jtv, ok := value.(string) 15619 if !ok { 15620 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15621 } 15622 sv.DockerVersion = ptr.String(jtv) 15623 } 15624 15625 default: 15626 _, _ = key, value 15627 15628 } 15629 } 15630 *v = sv 15631 return nil 15632} 15633 15634func awsAwsjson11_deserializeDocumentVolume(v **types.Volume, value interface{}) error { 15635 if v == nil { 15636 return fmt.Errorf("unexpected nil of type %T", v) 15637 } 15638 if value == nil { 15639 return nil 15640 } 15641 15642 shape, ok := value.(map[string]interface{}) 15643 if !ok { 15644 return fmt.Errorf("unexpected JSON type %v", value) 15645 } 15646 15647 var sv *types.Volume 15648 if *v == nil { 15649 sv = &types.Volume{} 15650 } else { 15651 sv = *v 15652 } 15653 15654 for key, value := range shape { 15655 switch key { 15656 case "dockerVolumeConfiguration": 15657 if err := awsAwsjson11_deserializeDocumentDockerVolumeConfiguration(&sv.DockerVolumeConfiguration, value); err != nil { 15658 return err 15659 } 15660 15661 case "efsVolumeConfiguration": 15662 if err := awsAwsjson11_deserializeDocumentEFSVolumeConfiguration(&sv.EfsVolumeConfiguration, value); err != nil { 15663 return err 15664 } 15665 15666 case "fsxWindowsFileServerVolumeConfiguration": 15667 if err := awsAwsjson11_deserializeDocumentFSxWindowsFileServerVolumeConfiguration(&sv.FsxWindowsFileServerVolumeConfiguration, value); err != nil { 15668 return err 15669 } 15670 15671 case "host": 15672 if err := awsAwsjson11_deserializeDocumentHostVolumeProperties(&sv.Host, value); err != nil { 15673 return err 15674 } 15675 15676 case "name": 15677 if value != nil { 15678 jtv, ok := value.(string) 15679 if !ok { 15680 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15681 } 15682 sv.Name = ptr.String(jtv) 15683 } 15684 15685 default: 15686 _, _ = key, value 15687 15688 } 15689 } 15690 *v = sv 15691 return nil 15692} 15693 15694func awsAwsjson11_deserializeDocumentVolumeFrom(v **types.VolumeFrom, value interface{}) error { 15695 if v == nil { 15696 return fmt.Errorf("unexpected nil of type %T", v) 15697 } 15698 if value == nil { 15699 return nil 15700 } 15701 15702 shape, ok := value.(map[string]interface{}) 15703 if !ok { 15704 return fmt.Errorf("unexpected JSON type %v", value) 15705 } 15706 15707 var sv *types.VolumeFrom 15708 if *v == nil { 15709 sv = &types.VolumeFrom{} 15710 } else { 15711 sv = *v 15712 } 15713 15714 for key, value := range shape { 15715 switch key { 15716 case "readOnly": 15717 if value != nil { 15718 jtv, ok := value.(bool) 15719 if !ok { 15720 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 15721 } 15722 sv.ReadOnly = ptr.Bool(jtv) 15723 } 15724 15725 case "sourceContainer": 15726 if value != nil { 15727 jtv, ok := value.(string) 15728 if !ok { 15729 return fmt.Errorf("expected String to be of type string, got %T instead", value) 15730 } 15731 sv.SourceContainer = ptr.String(jtv) 15732 } 15733 15734 default: 15735 _, _ = key, value 15736 15737 } 15738 } 15739 *v = sv 15740 return nil 15741} 15742 15743func awsAwsjson11_deserializeDocumentVolumeFromList(v *[]types.VolumeFrom, value interface{}) error { 15744 if v == nil { 15745 return fmt.Errorf("unexpected nil of type %T", v) 15746 } 15747 if value == nil { 15748 return nil 15749 } 15750 15751 shape, ok := value.([]interface{}) 15752 if !ok { 15753 return fmt.Errorf("unexpected JSON type %v", value) 15754 } 15755 15756 var cv []types.VolumeFrom 15757 if *v == nil { 15758 cv = []types.VolumeFrom{} 15759 } else { 15760 cv = *v 15761 } 15762 15763 for _, value := range shape { 15764 var col types.VolumeFrom 15765 destAddr := &col 15766 if err := awsAwsjson11_deserializeDocumentVolumeFrom(&destAddr, value); err != nil { 15767 return err 15768 } 15769 col = *destAddr 15770 cv = append(cv, col) 15771 15772 } 15773 *v = cv 15774 return nil 15775} 15776 15777func awsAwsjson11_deserializeDocumentVolumeList(v *[]types.Volume, value interface{}) error { 15778 if v == nil { 15779 return fmt.Errorf("unexpected nil of type %T", v) 15780 } 15781 if value == nil { 15782 return nil 15783 } 15784 15785 shape, ok := value.([]interface{}) 15786 if !ok { 15787 return fmt.Errorf("unexpected JSON type %v", value) 15788 } 15789 15790 var cv []types.Volume 15791 if *v == nil { 15792 cv = []types.Volume{} 15793 } else { 15794 cv = *v 15795 } 15796 15797 for _, value := range shape { 15798 var col types.Volume 15799 destAddr := &col 15800 if err := awsAwsjson11_deserializeDocumentVolume(&destAddr, value); err != nil { 15801 return err 15802 } 15803 col = *destAddr 15804 cv = append(cv, col) 15805 15806 } 15807 *v = cv 15808 return nil 15809} 15810 15811func awsAwsjson11_deserializeOpDocumentCreateCapacityProviderOutput(v **CreateCapacityProviderOutput, value interface{}) error { 15812 if v == nil { 15813 return fmt.Errorf("unexpected nil of type %T", v) 15814 } 15815 if value == nil { 15816 return nil 15817 } 15818 15819 shape, ok := value.(map[string]interface{}) 15820 if !ok { 15821 return fmt.Errorf("unexpected JSON type %v", value) 15822 } 15823 15824 var sv *CreateCapacityProviderOutput 15825 if *v == nil { 15826 sv = &CreateCapacityProviderOutput{} 15827 } else { 15828 sv = *v 15829 } 15830 15831 for key, value := range shape { 15832 switch key { 15833 case "capacityProvider": 15834 if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil { 15835 return err 15836 } 15837 15838 default: 15839 _, _ = key, value 15840 15841 } 15842 } 15843 *v = sv 15844 return nil 15845} 15846 15847func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, value interface{}) error { 15848 if v == nil { 15849 return fmt.Errorf("unexpected nil of type %T", v) 15850 } 15851 if value == nil { 15852 return nil 15853 } 15854 15855 shape, ok := value.(map[string]interface{}) 15856 if !ok { 15857 return fmt.Errorf("unexpected JSON type %v", value) 15858 } 15859 15860 var sv *CreateClusterOutput 15861 if *v == nil { 15862 sv = &CreateClusterOutput{} 15863 } else { 15864 sv = *v 15865 } 15866 15867 for key, value := range shape { 15868 switch key { 15869 case "cluster": 15870 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 15871 return err 15872 } 15873 15874 default: 15875 _, _ = key, value 15876 15877 } 15878 } 15879 *v = sv 15880 return nil 15881} 15882 15883func awsAwsjson11_deserializeOpDocumentCreateServiceOutput(v **CreateServiceOutput, value interface{}) error { 15884 if v == nil { 15885 return fmt.Errorf("unexpected nil of type %T", v) 15886 } 15887 if value == nil { 15888 return nil 15889 } 15890 15891 shape, ok := value.(map[string]interface{}) 15892 if !ok { 15893 return fmt.Errorf("unexpected JSON type %v", value) 15894 } 15895 15896 var sv *CreateServiceOutput 15897 if *v == nil { 15898 sv = &CreateServiceOutput{} 15899 } else { 15900 sv = *v 15901 } 15902 15903 for key, value := range shape { 15904 switch key { 15905 case "service": 15906 if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil { 15907 return err 15908 } 15909 15910 default: 15911 _, _ = key, value 15912 15913 } 15914 } 15915 *v = sv 15916 return nil 15917} 15918 15919func awsAwsjson11_deserializeOpDocumentCreateTaskSetOutput(v **CreateTaskSetOutput, value interface{}) error { 15920 if v == nil { 15921 return fmt.Errorf("unexpected nil of type %T", v) 15922 } 15923 if value == nil { 15924 return nil 15925 } 15926 15927 shape, ok := value.(map[string]interface{}) 15928 if !ok { 15929 return fmt.Errorf("unexpected JSON type %v", value) 15930 } 15931 15932 var sv *CreateTaskSetOutput 15933 if *v == nil { 15934 sv = &CreateTaskSetOutput{} 15935 } else { 15936 sv = *v 15937 } 15938 15939 for key, value := range shape { 15940 switch key { 15941 case "taskSet": 15942 if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil { 15943 return err 15944 } 15945 15946 default: 15947 _, _ = key, value 15948 15949 } 15950 } 15951 *v = sv 15952 return nil 15953} 15954 15955func awsAwsjson11_deserializeOpDocumentDeleteAccountSettingOutput(v **DeleteAccountSettingOutput, value interface{}) error { 15956 if v == nil { 15957 return fmt.Errorf("unexpected nil of type %T", v) 15958 } 15959 if value == nil { 15960 return nil 15961 } 15962 15963 shape, ok := value.(map[string]interface{}) 15964 if !ok { 15965 return fmt.Errorf("unexpected JSON type %v", value) 15966 } 15967 15968 var sv *DeleteAccountSettingOutput 15969 if *v == nil { 15970 sv = &DeleteAccountSettingOutput{} 15971 } else { 15972 sv = *v 15973 } 15974 15975 for key, value := range shape { 15976 switch key { 15977 case "setting": 15978 if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil { 15979 return err 15980 } 15981 15982 default: 15983 _, _ = key, value 15984 15985 } 15986 } 15987 *v = sv 15988 return nil 15989} 15990 15991func awsAwsjson11_deserializeOpDocumentDeleteAttributesOutput(v **DeleteAttributesOutput, value interface{}) error { 15992 if v == nil { 15993 return fmt.Errorf("unexpected nil of type %T", v) 15994 } 15995 if value == nil { 15996 return nil 15997 } 15998 15999 shape, ok := value.(map[string]interface{}) 16000 if !ok { 16001 return fmt.Errorf("unexpected JSON type %v", value) 16002 } 16003 16004 var sv *DeleteAttributesOutput 16005 if *v == nil { 16006 sv = &DeleteAttributesOutput{} 16007 } else { 16008 sv = *v 16009 } 16010 16011 for key, value := range shape { 16012 switch key { 16013 case "attributes": 16014 if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 16015 return err 16016 } 16017 16018 default: 16019 _, _ = key, value 16020 16021 } 16022 } 16023 *v = sv 16024 return nil 16025} 16026 16027func awsAwsjson11_deserializeOpDocumentDeleteCapacityProviderOutput(v **DeleteCapacityProviderOutput, value interface{}) error { 16028 if v == nil { 16029 return fmt.Errorf("unexpected nil of type %T", v) 16030 } 16031 if value == nil { 16032 return nil 16033 } 16034 16035 shape, ok := value.(map[string]interface{}) 16036 if !ok { 16037 return fmt.Errorf("unexpected JSON type %v", value) 16038 } 16039 16040 var sv *DeleteCapacityProviderOutput 16041 if *v == nil { 16042 sv = &DeleteCapacityProviderOutput{} 16043 } else { 16044 sv = *v 16045 } 16046 16047 for key, value := range shape { 16048 switch key { 16049 case "capacityProvider": 16050 if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil { 16051 return err 16052 } 16053 16054 default: 16055 _, _ = key, value 16056 16057 } 16058 } 16059 *v = sv 16060 return nil 16061} 16062 16063func awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(v **DeleteClusterOutput, value interface{}) error { 16064 if v == nil { 16065 return fmt.Errorf("unexpected nil of type %T", v) 16066 } 16067 if value == nil { 16068 return nil 16069 } 16070 16071 shape, ok := value.(map[string]interface{}) 16072 if !ok { 16073 return fmt.Errorf("unexpected JSON type %v", value) 16074 } 16075 16076 var sv *DeleteClusterOutput 16077 if *v == nil { 16078 sv = &DeleteClusterOutput{} 16079 } else { 16080 sv = *v 16081 } 16082 16083 for key, value := range shape { 16084 switch key { 16085 case "cluster": 16086 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 16087 return err 16088 } 16089 16090 default: 16091 _, _ = key, value 16092 16093 } 16094 } 16095 *v = sv 16096 return nil 16097} 16098 16099func awsAwsjson11_deserializeOpDocumentDeleteServiceOutput(v **DeleteServiceOutput, value interface{}) error { 16100 if v == nil { 16101 return fmt.Errorf("unexpected nil of type %T", v) 16102 } 16103 if value == nil { 16104 return nil 16105 } 16106 16107 shape, ok := value.(map[string]interface{}) 16108 if !ok { 16109 return fmt.Errorf("unexpected JSON type %v", value) 16110 } 16111 16112 var sv *DeleteServiceOutput 16113 if *v == nil { 16114 sv = &DeleteServiceOutput{} 16115 } else { 16116 sv = *v 16117 } 16118 16119 for key, value := range shape { 16120 switch key { 16121 case "service": 16122 if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil { 16123 return err 16124 } 16125 16126 default: 16127 _, _ = key, value 16128 16129 } 16130 } 16131 *v = sv 16132 return nil 16133} 16134 16135func awsAwsjson11_deserializeOpDocumentDeleteTaskSetOutput(v **DeleteTaskSetOutput, value interface{}) error { 16136 if v == nil { 16137 return fmt.Errorf("unexpected nil of type %T", v) 16138 } 16139 if value == nil { 16140 return nil 16141 } 16142 16143 shape, ok := value.(map[string]interface{}) 16144 if !ok { 16145 return fmt.Errorf("unexpected JSON type %v", value) 16146 } 16147 16148 var sv *DeleteTaskSetOutput 16149 if *v == nil { 16150 sv = &DeleteTaskSetOutput{} 16151 } else { 16152 sv = *v 16153 } 16154 16155 for key, value := range shape { 16156 switch key { 16157 case "taskSet": 16158 if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil { 16159 return err 16160 } 16161 16162 default: 16163 _, _ = key, value 16164 16165 } 16166 } 16167 *v = sv 16168 return nil 16169} 16170 16171func awsAwsjson11_deserializeOpDocumentDeregisterContainerInstanceOutput(v **DeregisterContainerInstanceOutput, value interface{}) error { 16172 if v == nil { 16173 return fmt.Errorf("unexpected nil of type %T", v) 16174 } 16175 if value == nil { 16176 return nil 16177 } 16178 16179 shape, ok := value.(map[string]interface{}) 16180 if !ok { 16181 return fmt.Errorf("unexpected JSON type %v", value) 16182 } 16183 16184 var sv *DeregisterContainerInstanceOutput 16185 if *v == nil { 16186 sv = &DeregisterContainerInstanceOutput{} 16187 } else { 16188 sv = *v 16189 } 16190 16191 for key, value := range shape { 16192 switch key { 16193 case "containerInstance": 16194 if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil { 16195 return err 16196 } 16197 16198 default: 16199 _, _ = key, value 16200 16201 } 16202 } 16203 *v = sv 16204 return nil 16205} 16206 16207func awsAwsjson11_deserializeOpDocumentDeregisterTaskDefinitionOutput(v **DeregisterTaskDefinitionOutput, value interface{}) error { 16208 if v == nil { 16209 return fmt.Errorf("unexpected nil of type %T", v) 16210 } 16211 if value == nil { 16212 return nil 16213 } 16214 16215 shape, ok := value.(map[string]interface{}) 16216 if !ok { 16217 return fmt.Errorf("unexpected JSON type %v", value) 16218 } 16219 16220 var sv *DeregisterTaskDefinitionOutput 16221 if *v == nil { 16222 sv = &DeregisterTaskDefinitionOutput{} 16223 } else { 16224 sv = *v 16225 } 16226 16227 for key, value := range shape { 16228 switch key { 16229 case "taskDefinition": 16230 if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil { 16231 return err 16232 } 16233 16234 default: 16235 _, _ = key, value 16236 16237 } 16238 } 16239 *v = sv 16240 return nil 16241} 16242 16243func awsAwsjson11_deserializeOpDocumentDescribeCapacityProvidersOutput(v **DescribeCapacityProvidersOutput, value interface{}) error { 16244 if v == nil { 16245 return fmt.Errorf("unexpected nil of type %T", v) 16246 } 16247 if value == nil { 16248 return nil 16249 } 16250 16251 shape, ok := value.(map[string]interface{}) 16252 if !ok { 16253 return fmt.Errorf("unexpected JSON type %v", value) 16254 } 16255 16256 var sv *DescribeCapacityProvidersOutput 16257 if *v == nil { 16258 sv = &DescribeCapacityProvidersOutput{} 16259 } else { 16260 sv = *v 16261 } 16262 16263 for key, value := range shape { 16264 switch key { 16265 case "capacityProviders": 16266 if err := awsAwsjson11_deserializeDocumentCapacityProviders(&sv.CapacityProviders, value); err != nil { 16267 return err 16268 } 16269 16270 case "failures": 16271 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16272 return err 16273 } 16274 16275 case "nextToken": 16276 if value != nil { 16277 jtv, ok := value.(string) 16278 if !ok { 16279 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16280 } 16281 sv.NextToken = ptr.String(jtv) 16282 } 16283 16284 default: 16285 _, _ = key, value 16286 16287 } 16288 } 16289 *v = sv 16290 return nil 16291} 16292 16293func awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(v **DescribeClustersOutput, value interface{}) error { 16294 if v == nil { 16295 return fmt.Errorf("unexpected nil of type %T", v) 16296 } 16297 if value == nil { 16298 return nil 16299 } 16300 16301 shape, ok := value.(map[string]interface{}) 16302 if !ok { 16303 return fmt.Errorf("unexpected JSON type %v", value) 16304 } 16305 16306 var sv *DescribeClustersOutput 16307 if *v == nil { 16308 sv = &DescribeClustersOutput{} 16309 } else { 16310 sv = *v 16311 } 16312 16313 for key, value := range shape { 16314 switch key { 16315 case "clusters": 16316 if err := awsAwsjson11_deserializeDocumentClusters(&sv.Clusters, value); err != nil { 16317 return err 16318 } 16319 16320 case "failures": 16321 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16322 return err 16323 } 16324 16325 default: 16326 _, _ = key, value 16327 16328 } 16329 } 16330 *v = sv 16331 return nil 16332} 16333 16334func awsAwsjson11_deserializeOpDocumentDescribeContainerInstancesOutput(v **DescribeContainerInstancesOutput, value interface{}) error { 16335 if v == nil { 16336 return fmt.Errorf("unexpected nil of type %T", v) 16337 } 16338 if value == nil { 16339 return nil 16340 } 16341 16342 shape, ok := value.(map[string]interface{}) 16343 if !ok { 16344 return fmt.Errorf("unexpected JSON type %v", value) 16345 } 16346 16347 var sv *DescribeContainerInstancesOutput 16348 if *v == nil { 16349 sv = &DescribeContainerInstancesOutput{} 16350 } else { 16351 sv = *v 16352 } 16353 16354 for key, value := range shape { 16355 switch key { 16356 case "containerInstances": 16357 if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil { 16358 return err 16359 } 16360 16361 case "failures": 16362 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16363 return err 16364 } 16365 16366 default: 16367 _, _ = key, value 16368 16369 } 16370 } 16371 *v = sv 16372 return nil 16373} 16374 16375func awsAwsjson11_deserializeOpDocumentDescribeServicesOutput(v **DescribeServicesOutput, value interface{}) error { 16376 if v == nil { 16377 return fmt.Errorf("unexpected nil of type %T", v) 16378 } 16379 if value == nil { 16380 return nil 16381 } 16382 16383 shape, ok := value.(map[string]interface{}) 16384 if !ok { 16385 return fmt.Errorf("unexpected JSON type %v", value) 16386 } 16387 16388 var sv *DescribeServicesOutput 16389 if *v == nil { 16390 sv = &DescribeServicesOutput{} 16391 } else { 16392 sv = *v 16393 } 16394 16395 for key, value := range shape { 16396 switch key { 16397 case "failures": 16398 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16399 return err 16400 } 16401 16402 case "services": 16403 if err := awsAwsjson11_deserializeDocumentServices(&sv.Services, value); err != nil { 16404 return err 16405 } 16406 16407 default: 16408 _, _ = key, value 16409 16410 } 16411 } 16412 *v = sv 16413 return nil 16414} 16415 16416func awsAwsjson11_deserializeOpDocumentDescribeTaskDefinitionOutput(v **DescribeTaskDefinitionOutput, value interface{}) error { 16417 if v == nil { 16418 return fmt.Errorf("unexpected nil of type %T", v) 16419 } 16420 if value == nil { 16421 return nil 16422 } 16423 16424 shape, ok := value.(map[string]interface{}) 16425 if !ok { 16426 return fmt.Errorf("unexpected JSON type %v", value) 16427 } 16428 16429 var sv *DescribeTaskDefinitionOutput 16430 if *v == nil { 16431 sv = &DescribeTaskDefinitionOutput{} 16432 } else { 16433 sv = *v 16434 } 16435 16436 for key, value := range shape { 16437 switch key { 16438 case "tags": 16439 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16440 return err 16441 } 16442 16443 case "taskDefinition": 16444 if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil { 16445 return err 16446 } 16447 16448 default: 16449 _, _ = key, value 16450 16451 } 16452 } 16453 *v = sv 16454 return nil 16455} 16456 16457func awsAwsjson11_deserializeOpDocumentDescribeTaskSetsOutput(v **DescribeTaskSetsOutput, value interface{}) error { 16458 if v == nil { 16459 return fmt.Errorf("unexpected nil of type %T", v) 16460 } 16461 if value == nil { 16462 return nil 16463 } 16464 16465 shape, ok := value.(map[string]interface{}) 16466 if !ok { 16467 return fmt.Errorf("unexpected JSON type %v", value) 16468 } 16469 16470 var sv *DescribeTaskSetsOutput 16471 if *v == nil { 16472 sv = &DescribeTaskSetsOutput{} 16473 } else { 16474 sv = *v 16475 } 16476 16477 for key, value := range shape { 16478 switch key { 16479 case "failures": 16480 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16481 return err 16482 } 16483 16484 case "taskSets": 16485 if err := awsAwsjson11_deserializeDocumentTaskSets(&sv.TaskSets, value); err != nil { 16486 return err 16487 } 16488 16489 default: 16490 _, _ = key, value 16491 16492 } 16493 } 16494 *v = sv 16495 return nil 16496} 16497 16498func awsAwsjson11_deserializeOpDocumentDescribeTasksOutput(v **DescribeTasksOutput, value interface{}) error { 16499 if v == nil { 16500 return fmt.Errorf("unexpected nil of type %T", v) 16501 } 16502 if value == nil { 16503 return nil 16504 } 16505 16506 shape, ok := value.(map[string]interface{}) 16507 if !ok { 16508 return fmt.Errorf("unexpected JSON type %v", value) 16509 } 16510 16511 var sv *DescribeTasksOutput 16512 if *v == nil { 16513 sv = &DescribeTasksOutput{} 16514 } else { 16515 sv = *v 16516 } 16517 16518 for key, value := range shape { 16519 switch key { 16520 case "failures": 16521 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 16522 return err 16523 } 16524 16525 case "tasks": 16526 if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil { 16527 return err 16528 } 16529 16530 default: 16531 _, _ = key, value 16532 16533 } 16534 } 16535 *v = sv 16536 return nil 16537} 16538 16539func awsAwsjson11_deserializeOpDocumentDiscoverPollEndpointOutput(v **DiscoverPollEndpointOutput, value interface{}) error { 16540 if v == nil { 16541 return fmt.Errorf("unexpected nil of type %T", v) 16542 } 16543 if value == nil { 16544 return nil 16545 } 16546 16547 shape, ok := value.(map[string]interface{}) 16548 if !ok { 16549 return fmt.Errorf("unexpected JSON type %v", value) 16550 } 16551 16552 var sv *DiscoverPollEndpointOutput 16553 if *v == nil { 16554 sv = &DiscoverPollEndpointOutput{} 16555 } else { 16556 sv = *v 16557 } 16558 16559 for key, value := range shape { 16560 switch key { 16561 case "endpoint": 16562 if value != nil { 16563 jtv, ok := value.(string) 16564 if !ok { 16565 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16566 } 16567 sv.Endpoint = ptr.String(jtv) 16568 } 16569 16570 case "telemetryEndpoint": 16571 if value != nil { 16572 jtv, ok := value.(string) 16573 if !ok { 16574 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16575 } 16576 sv.TelemetryEndpoint = ptr.String(jtv) 16577 } 16578 16579 default: 16580 _, _ = key, value 16581 16582 } 16583 } 16584 *v = sv 16585 return nil 16586} 16587 16588func awsAwsjson11_deserializeOpDocumentExecuteCommandOutput(v **ExecuteCommandOutput, value interface{}) error { 16589 if v == nil { 16590 return fmt.Errorf("unexpected nil of type %T", v) 16591 } 16592 if value == nil { 16593 return nil 16594 } 16595 16596 shape, ok := value.(map[string]interface{}) 16597 if !ok { 16598 return fmt.Errorf("unexpected JSON type %v", value) 16599 } 16600 16601 var sv *ExecuteCommandOutput 16602 if *v == nil { 16603 sv = &ExecuteCommandOutput{} 16604 } else { 16605 sv = *v 16606 } 16607 16608 for key, value := range shape { 16609 switch key { 16610 case "clusterArn": 16611 if value != nil { 16612 jtv, ok := value.(string) 16613 if !ok { 16614 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16615 } 16616 sv.ClusterArn = ptr.String(jtv) 16617 } 16618 16619 case "containerArn": 16620 if value != nil { 16621 jtv, ok := value.(string) 16622 if !ok { 16623 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16624 } 16625 sv.ContainerArn = ptr.String(jtv) 16626 } 16627 16628 case "containerName": 16629 if value != nil { 16630 jtv, ok := value.(string) 16631 if !ok { 16632 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16633 } 16634 sv.ContainerName = ptr.String(jtv) 16635 } 16636 16637 case "interactive": 16638 if value != nil { 16639 jtv, ok := value.(bool) 16640 if !ok { 16641 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 16642 } 16643 sv.Interactive = jtv 16644 } 16645 16646 case "session": 16647 if err := awsAwsjson11_deserializeDocumentSession(&sv.Session, value); err != nil { 16648 return err 16649 } 16650 16651 case "taskArn": 16652 if value != nil { 16653 jtv, ok := value.(string) 16654 if !ok { 16655 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16656 } 16657 sv.TaskArn = ptr.String(jtv) 16658 } 16659 16660 default: 16661 _, _ = key, value 16662 16663 } 16664 } 16665 *v = sv 16666 return nil 16667} 16668 16669func awsAwsjson11_deserializeOpDocumentListAccountSettingsOutput(v **ListAccountSettingsOutput, value interface{}) error { 16670 if v == nil { 16671 return fmt.Errorf("unexpected nil of type %T", v) 16672 } 16673 if value == nil { 16674 return nil 16675 } 16676 16677 shape, ok := value.(map[string]interface{}) 16678 if !ok { 16679 return fmt.Errorf("unexpected JSON type %v", value) 16680 } 16681 16682 var sv *ListAccountSettingsOutput 16683 if *v == nil { 16684 sv = &ListAccountSettingsOutput{} 16685 } else { 16686 sv = *v 16687 } 16688 16689 for key, value := range shape { 16690 switch key { 16691 case "nextToken": 16692 if value != nil { 16693 jtv, ok := value.(string) 16694 if !ok { 16695 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16696 } 16697 sv.NextToken = ptr.String(jtv) 16698 } 16699 16700 case "settings": 16701 if err := awsAwsjson11_deserializeDocumentSettings(&sv.Settings, value); err != nil { 16702 return err 16703 } 16704 16705 default: 16706 _, _ = key, value 16707 16708 } 16709 } 16710 *v = sv 16711 return nil 16712} 16713 16714func awsAwsjson11_deserializeOpDocumentListAttributesOutput(v **ListAttributesOutput, value interface{}) error { 16715 if v == nil { 16716 return fmt.Errorf("unexpected nil of type %T", v) 16717 } 16718 if value == nil { 16719 return nil 16720 } 16721 16722 shape, ok := value.(map[string]interface{}) 16723 if !ok { 16724 return fmt.Errorf("unexpected JSON type %v", value) 16725 } 16726 16727 var sv *ListAttributesOutput 16728 if *v == nil { 16729 sv = &ListAttributesOutput{} 16730 } else { 16731 sv = *v 16732 } 16733 16734 for key, value := range shape { 16735 switch key { 16736 case "attributes": 16737 if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 16738 return err 16739 } 16740 16741 case "nextToken": 16742 if value != nil { 16743 jtv, ok := value.(string) 16744 if !ok { 16745 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16746 } 16747 sv.NextToken = ptr.String(jtv) 16748 } 16749 16750 default: 16751 _, _ = key, value 16752 16753 } 16754 } 16755 *v = sv 16756 return nil 16757} 16758 16759func awsAwsjson11_deserializeOpDocumentListClustersOutput(v **ListClustersOutput, value interface{}) error { 16760 if v == nil { 16761 return fmt.Errorf("unexpected nil of type %T", v) 16762 } 16763 if value == nil { 16764 return nil 16765 } 16766 16767 shape, ok := value.(map[string]interface{}) 16768 if !ok { 16769 return fmt.Errorf("unexpected JSON type %v", value) 16770 } 16771 16772 var sv *ListClustersOutput 16773 if *v == nil { 16774 sv = &ListClustersOutput{} 16775 } else { 16776 sv = *v 16777 } 16778 16779 for key, value := range shape { 16780 switch key { 16781 case "clusterArns": 16782 if err := awsAwsjson11_deserializeDocumentStringList(&sv.ClusterArns, value); err != nil { 16783 return err 16784 } 16785 16786 case "nextToken": 16787 if value != nil { 16788 jtv, ok := value.(string) 16789 if !ok { 16790 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16791 } 16792 sv.NextToken = ptr.String(jtv) 16793 } 16794 16795 default: 16796 _, _ = key, value 16797 16798 } 16799 } 16800 *v = sv 16801 return nil 16802} 16803 16804func awsAwsjson11_deserializeOpDocumentListContainerInstancesOutput(v **ListContainerInstancesOutput, value interface{}) error { 16805 if v == nil { 16806 return fmt.Errorf("unexpected nil of type %T", v) 16807 } 16808 if value == nil { 16809 return nil 16810 } 16811 16812 shape, ok := value.(map[string]interface{}) 16813 if !ok { 16814 return fmt.Errorf("unexpected JSON type %v", value) 16815 } 16816 16817 var sv *ListContainerInstancesOutput 16818 if *v == nil { 16819 sv = &ListContainerInstancesOutput{} 16820 } else { 16821 sv = *v 16822 } 16823 16824 for key, value := range shape { 16825 switch key { 16826 case "containerInstanceArns": 16827 if err := awsAwsjson11_deserializeDocumentStringList(&sv.ContainerInstanceArns, value); err != nil { 16828 return err 16829 } 16830 16831 case "nextToken": 16832 if value != nil { 16833 jtv, ok := value.(string) 16834 if !ok { 16835 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16836 } 16837 sv.NextToken = ptr.String(jtv) 16838 } 16839 16840 default: 16841 _, _ = key, value 16842 16843 } 16844 } 16845 *v = sv 16846 return nil 16847} 16848 16849func awsAwsjson11_deserializeOpDocumentListServicesOutput(v **ListServicesOutput, value interface{}) error { 16850 if v == nil { 16851 return fmt.Errorf("unexpected nil of type %T", v) 16852 } 16853 if value == nil { 16854 return nil 16855 } 16856 16857 shape, ok := value.(map[string]interface{}) 16858 if !ok { 16859 return fmt.Errorf("unexpected JSON type %v", value) 16860 } 16861 16862 var sv *ListServicesOutput 16863 if *v == nil { 16864 sv = &ListServicesOutput{} 16865 } else { 16866 sv = *v 16867 } 16868 16869 for key, value := range shape { 16870 switch key { 16871 case "nextToken": 16872 if value != nil { 16873 jtv, ok := value.(string) 16874 if !ok { 16875 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16876 } 16877 sv.NextToken = ptr.String(jtv) 16878 } 16879 16880 case "serviceArns": 16881 if err := awsAwsjson11_deserializeDocumentStringList(&sv.ServiceArns, value); err != nil { 16882 return err 16883 } 16884 16885 default: 16886 _, _ = key, value 16887 16888 } 16889 } 16890 *v = sv 16891 return nil 16892} 16893 16894func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 16895 if v == nil { 16896 return fmt.Errorf("unexpected nil of type %T", v) 16897 } 16898 if value == nil { 16899 return nil 16900 } 16901 16902 shape, ok := value.(map[string]interface{}) 16903 if !ok { 16904 return fmt.Errorf("unexpected JSON type %v", value) 16905 } 16906 16907 var sv *ListTagsForResourceOutput 16908 if *v == nil { 16909 sv = &ListTagsForResourceOutput{} 16910 } else { 16911 sv = *v 16912 } 16913 16914 for key, value := range shape { 16915 switch key { 16916 case "tags": 16917 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16918 return err 16919 } 16920 16921 default: 16922 _, _ = key, value 16923 16924 } 16925 } 16926 *v = sv 16927 return nil 16928} 16929 16930func awsAwsjson11_deserializeOpDocumentListTaskDefinitionFamiliesOutput(v **ListTaskDefinitionFamiliesOutput, value interface{}) error { 16931 if v == nil { 16932 return fmt.Errorf("unexpected nil of type %T", v) 16933 } 16934 if value == nil { 16935 return nil 16936 } 16937 16938 shape, ok := value.(map[string]interface{}) 16939 if !ok { 16940 return fmt.Errorf("unexpected JSON type %v", value) 16941 } 16942 16943 var sv *ListTaskDefinitionFamiliesOutput 16944 if *v == nil { 16945 sv = &ListTaskDefinitionFamiliesOutput{} 16946 } else { 16947 sv = *v 16948 } 16949 16950 for key, value := range shape { 16951 switch key { 16952 case "families": 16953 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Families, value); err != nil { 16954 return err 16955 } 16956 16957 case "nextToken": 16958 if value != nil { 16959 jtv, ok := value.(string) 16960 if !ok { 16961 return fmt.Errorf("expected String to be of type string, got %T instead", value) 16962 } 16963 sv.NextToken = ptr.String(jtv) 16964 } 16965 16966 default: 16967 _, _ = key, value 16968 16969 } 16970 } 16971 *v = sv 16972 return nil 16973} 16974 16975func awsAwsjson11_deserializeOpDocumentListTaskDefinitionsOutput(v **ListTaskDefinitionsOutput, value interface{}) error { 16976 if v == nil { 16977 return fmt.Errorf("unexpected nil of type %T", v) 16978 } 16979 if value == nil { 16980 return nil 16981 } 16982 16983 shape, ok := value.(map[string]interface{}) 16984 if !ok { 16985 return fmt.Errorf("unexpected JSON type %v", value) 16986 } 16987 16988 var sv *ListTaskDefinitionsOutput 16989 if *v == nil { 16990 sv = &ListTaskDefinitionsOutput{} 16991 } else { 16992 sv = *v 16993 } 16994 16995 for key, value := range shape { 16996 switch key { 16997 case "nextToken": 16998 if value != nil { 16999 jtv, ok := value.(string) 17000 if !ok { 17001 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17002 } 17003 sv.NextToken = ptr.String(jtv) 17004 } 17005 17006 case "taskDefinitionArns": 17007 if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskDefinitionArns, value); err != nil { 17008 return err 17009 } 17010 17011 default: 17012 _, _ = key, value 17013 17014 } 17015 } 17016 *v = sv 17017 return nil 17018} 17019 17020func awsAwsjson11_deserializeOpDocumentListTasksOutput(v **ListTasksOutput, value interface{}) error { 17021 if v == nil { 17022 return fmt.Errorf("unexpected nil of type %T", v) 17023 } 17024 if value == nil { 17025 return nil 17026 } 17027 17028 shape, ok := value.(map[string]interface{}) 17029 if !ok { 17030 return fmt.Errorf("unexpected JSON type %v", value) 17031 } 17032 17033 var sv *ListTasksOutput 17034 if *v == nil { 17035 sv = &ListTasksOutput{} 17036 } else { 17037 sv = *v 17038 } 17039 17040 for key, value := range shape { 17041 switch key { 17042 case "nextToken": 17043 if value != nil { 17044 jtv, ok := value.(string) 17045 if !ok { 17046 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17047 } 17048 sv.NextToken = ptr.String(jtv) 17049 } 17050 17051 case "taskArns": 17052 if err := awsAwsjson11_deserializeDocumentStringList(&sv.TaskArns, value); err != nil { 17053 return err 17054 } 17055 17056 default: 17057 _, _ = key, value 17058 17059 } 17060 } 17061 *v = sv 17062 return nil 17063} 17064 17065func awsAwsjson11_deserializeOpDocumentPutAccountSettingDefaultOutput(v **PutAccountSettingDefaultOutput, value interface{}) error { 17066 if v == nil { 17067 return fmt.Errorf("unexpected nil of type %T", v) 17068 } 17069 if value == nil { 17070 return nil 17071 } 17072 17073 shape, ok := value.(map[string]interface{}) 17074 if !ok { 17075 return fmt.Errorf("unexpected JSON type %v", value) 17076 } 17077 17078 var sv *PutAccountSettingDefaultOutput 17079 if *v == nil { 17080 sv = &PutAccountSettingDefaultOutput{} 17081 } else { 17082 sv = *v 17083 } 17084 17085 for key, value := range shape { 17086 switch key { 17087 case "setting": 17088 if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil { 17089 return err 17090 } 17091 17092 default: 17093 _, _ = key, value 17094 17095 } 17096 } 17097 *v = sv 17098 return nil 17099} 17100 17101func awsAwsjson11_deserializeOpDocumentPutAccountSettingOutput(v **PutAccountSettingOutput, value interface{}) error { 17102 if v == nil { 17103 return fmt.Errorf("unexpected nil of type %T", v) 17104 } 17105 if value == nil { 17106 return nil 17107 } 17108 17109 shape, ok := value.(map[string]interface{}) 17110 if !ok { 17111 return fmt.Errorf("unexpected JSON type %v", value) 17112 } 17113 17114 var sv *PutAccountSettingOutput 17115 if *v == nil { 17116 sv = &PutAccountSettingOutput{} 17117 } else { 17118 sv = *v 17119 } 17120 17121 for key, value := range shape { 17122 switch key { 17123 case "setting": 17124 if err := awsAwsjson11_deserializeDocumentSetting(&sv.Setting, value); err != nil { 17125 return err 17126 } 17127 17128 default: 17129 _, _ = key, value 17130 17131 } 17132 } 17133 *v = sv 17134 return nil 17135} 17136 17137func awsAwsjson11_deserializeOpDocumentPutAttributesOutput(v **PutAttributesOutput, value interface{}) error { 17138 if v == nil { 17139 return fmt.Errorf("unexpected nil of type %T", v) 17140 } 17141 if value == nil { 17142 return nil 17143 } 17144 17145 shape, ok := value.(map[string]interface{}) 17146 if !ok { 17147 return fmt.Errorf("unexpected JSON type %v", value) 17148 } 17149 17150 var sv *PutAttributesOutput 17151 if *v == nil { 17152 sv = &PutAttributesOutput{} 17153 } else { 17154 sv = *v 17155 } 17156 17157 for key, value := range shape { 17158 switch key { 17159 case "attributes": 17160 if err := awsAwsjson11_deserializeDocumentAttributes(&sv.Attributes, value); err != nil { 17161 return err 17162 } 17163 17164 default: 17165 _, _ = key, value 17166 17167 } 17168 } 17169 *v = sv 17170 return nil 17171} 17172 17173func awsAwsjson11_deserializeOpDocumentPutClusterCapacityProvidersOutput(v **PutClusterCapacityProvidersOutput, value interface{}) error { 17174 if v == nil { 17175 return fmt.Errorf("unexpected nil of type %T", v) 17176 } 17177 if value == nil { 17178 return nil 17179 } 17180 17181 shape, ok := value.(map[string]interface{}) 17182 if !ok { 17183 return fmt.Errorf("unexpected JSON type %v", value) 17184 } 17185 17186 var sv *PutClusterCapacityProvidersOutput 17187 if *v == nil { 17188 sv = &PutClusterCapacityProvidersOutput{} 17189 } else { 17190 sv = *v 17191 } 17192 17193 for key, value := range shape { 17194 switch key { 17195 case "cluster": 17196 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 17197 return err 17198 } 17199 17200 default: 17201 _, _ = key, value 17202 17203 } 17204 } 17205 *v = sv 17206 return nil 17207} 17208 17209func awsAwsjson11_deserializeOpDocumentRegisterContainerInstanceOutput(v **RegisterContainerInstanceOutput, value interface{}) error { 17210 if v == nil { 17211 return fmt.Errorf("unexpected nil of type %T", v) 17212 } 17213 if value == nil { 17214 return nil 17215 } 17216 17217 shape, ok := value.(map[string]interface{}) 17218 if !ok { 17219 return fmt.Errorf("unexpected JSON type %v", value) 17220 } 17221 17222 var sv *RegisterContainerInstanceOutput 17223 if *v == nil { 17224 sv = &RegisterContainerInstanceOutput{} 17225 } else { 17226 sv = *v 17227 } 17228 17229 for key, value := range shape { 17230 switch key { 17231 case "containerInstance": 17232 if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil { 17233 return err 17234 } 17235 17236 default: 17237 _, _ = key, value 17238 17239 } 17240 } 17241 *v = sv 17242 return nil 17243} 17244 17245func awsAwsjson11_deserializeOpDocumentRegisterTaskDefinitionOutput(v **RegisterTaskDefinitionOutput, value interface{}) error { 17246 if v == nil { 17247 return fmt.Errorf("unexpected nil of type %T", v) 17248 } 17249 if value == nil { 17250 return nil 17251 } 17252 17253 shape, ok := value.(map[string]interface{}) 17254 if !ok { 17255 return fmt.Errorf("unexpected JSON type %v", value) 17256 } 17257 17258 var sv *RegisterTaskDefinitionOutput 17259 if *v == nil { 17260 sv = &RegisterTaskDefinitionOutput{} 17261 } else { 17262 sv = *v 17263 } 17264 17265 for key, value := range shape { 17266 switch key { 17267 case "tags": 17268 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 17269 return err 17270 } 17271 17272 case "taskDefinition": 17273 if err := awsAwsjson11_deserializeDocumentTaskDefinition(&sv.TaskDefinition, value); err != nil { 17274 return err 17275 } 17276 17277 default: 17278 _, _ = key, value 17279 17280 } 17281 } 17282 *v = sv 17283 return nil 17284} 17285 17286func awsAwsjson11_deserializeOpDocumentRunTaskOutput(v **RunTaskOutput, value interface{}) error { 17287 if v == nil { 17288 return fmt.Errorf("unexpected nil of type %T", v) 17289 } 17290 if value == nil { 17291 return nil 17292 } 17293 17294 shape, ok := value.(map[string]interface{}) 17295 if !ok { 17296 return fmt.Errorf("unexpected JSON type %v", value) 17297 } 17298 17299 var sv *RunTaskOutput 17300 if *v == nil { 17301 sv = &RunTaskOutput{} 17302 } else { 17303 sv = *v 17304 } 17305 17306 for key, value := range shape { 17307 switch key { 17308 case "failures": 17309 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 17310 return err 17311 } 17312 17313 case "tasks": 17314 if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil { 17315 return err 17316 } 17317 17318 default: 17319 _, _ = key, value 17320 17321 } 17322 } 17323 *v = sv 17324 return nil 17325} 17326 17327func awsAwsjson11_deserializeOpDocumentStartTaskOutput(v **StartTaskOutput, value interface{}) error { 17328 if v == nil { 17329 return fmt.Errorf("unexpected nil of type %T", v) 17330 } 17331 if value == nil { 17332 return nil 17333 } 17334 17335 shape, ok := value.(map[string]interface{}) 17336 if !ok { 17337 return fmt.Errorf("unexpected JSON type %v", value) 17338 } 17339 17340 var sv *StartTaskOutput 17341 if *v == nil { 17342 sv = &StartTaskOutput{} 17343 } else { 17344 sv = *v 17345 } 17346 17347 for key, value := range shape { 17348 switch key { 17349 case "failures": 17350 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 17351 return err 17352 } 17353 17354 case "tasks": 17355 if err := awsAwsjson11_deserializeDocumentTasks(&sv.Tasks, value); err != nil { 17356 return err 17357 } 17358 17359 default: 17360 _, _ = key, value 17361 17362 } 17363 } 17364 *v = sv 17365 return nil 17366} 17367 17368func awsAwsjson11_deserializeOpDocumentStopTaskOutput(v **StopTaskOutput, value interface{}) error { 17369 if v == nil { 17370 return fmt.Errorf("unexpected nil of type %T", v) 17371 } 17372 if value == nil { 17373 return nil 17374 } 17375 17376 shape, ok := value.(map[string]interface{}) 17377 if !ok { 17378 return fmt.Errorf("unexpected JSON type %v", value) 17379 } 17380 17381 var sv *StopTaskOutput 17382 if *v == nil { 17383 sv = &StopTaskOutput{} 17384 } else { 17385 sv = *v 17386 } 17387 17388 for key, value := range shape { 17389 switch key { 17390 case "task": 17391 if err := awsAwsjson11_deserializeDocumentTask(&sv.Task, value); err != nil { 17392 return err 17393 } 17394 17395 default: 17396 _, _ = key, value 17397 17398 } 17399 } 17400 *v = sv 17401 return nil 17402} 17403 17404func awsAwsjson11_deserializeOpDocumentSubmitAttachmentStateChangesOutput(v **SubmitAttachmentStateChangesOutput, value interface{}) error { 17405 if v == nil { 17406 return fmt.Errorf("unexpected nil of type %T", v) 17407 } 17408 if value == nil { 17409 return nil 17410 } 17411 17412 shape, ok := value.(map[string]interface{}) 17413 if !ok { 17414 return fmt.Errorf("unexpected JSON type %v", value) 17415 } 17416 17417 var sv *SubmitAttachmentStateChangesOutput 17418 if *v == nil { 17419 sv = &SubmitAttachmentStateChangesOutput{} 17420 } else { 17421 sv = *v 17422 } 17423 17424 for key, value := range shape { 17425 switch key { 17426 case "acknowledgment": 17427 if value != nil { 17428 jtv, ok := value.(string) 17429 if !ok { 17430 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17431 } 17432 sv.Acknowledgment = ptr.String(jtv) 17433 } 17434 17435 default: 17436 _, _ = key, value 17437 17438 } 17439 } 17440 *v = sv 17441 return nil 17442} 17443 17444func awsAwsjson11_deserializeOpDocumentSubmitContainerStateChangeOutput(v **SubmitContainerStateChangeOutput, value interface{}) error { 17445 if v == nil { 17446 return fmt.Errorf("unexpected nil of type %T", v) 17447 } 17448 if value == nil { 17449 return nil 17450 } 17451 17452 shape, ok := value.(map[string]interface{}) 17453 if !ok { 17454 return fmt.Errorf("unexpected JSON type %v", value) 17455 } 17456 17457 var sv *SubmitContainerStateChangeOutput 17458 if *v == nil { 17459 sv = &SubmitContainerStateChangeOutput{} 17460 } else { 17461 sv = *v 17462 } 17463 17464 for key, value := range shape { 17465 switch key { 17466 case "acknowledgment": 17467 if value != nil { 17468 jtv, ok := value.(string) 17469 if !ok { 17470 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17471 } 17472 sv.Acknowledgment = ptr.String(jtv) 17473 } 17474 17475 default: 17476 _, _ = key, value 17477 17478 } 17479 } 17480 *v = sv 17481 return nil 17482} 17483 17484func awsAwsjson11_deserializeOpDocumentSubmitTaskStateChangeOutput(v **SubmitTaskStateChangeOutput, value interface{}) error { 17485 if v == nil { 17486 return fmt.Errorf("unexpected nil of type %T", v) 17487 } 17488 if value == nil { 17489 return nil 17490 } 17491 17492 shape, ok := value.(map[string]interface{}) 17493 if !ok { 17494 return fmt.Errorf("unexpected JSON type %v", value) 17495 } 17496 17497 var sv *SubmitTaskStateChangeOutput 17498 if *v == nil { 17499 sv = &SubmitTaskStateChangeOutput{} 17500 } else { 17501 sv = *v 17502 } 17503 17504 for key, value := range shape { 17505 switch key { 17506 case "acknowledgment": 17507 if value != nil { 17508 jtv, ok := value.(string) 17509 if !ok { 17510 return fmt.Errorf("expected String to be of type string, got %T instead", value) 17511 } 17512 sv.Acknowledgment = ptr.String(jtv) 17513 } 17514 17515 default: 17516 _, _ = key, value 17517 17518 } 17519 } 17520 *v = sv 17521 return nil 17522} 17523 17524func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 17525 if v == nil { 17526 return fmt.Errorf("unexpected nil of type %T", v) 17527 } 17528 if value == nil { 17529 return nil 17530 } 17531 17532 shape, ok := value.(map[string]interface{}) 17533 if !ok { 17534 return fmt.Errorf("unexpected JSON type %v", value) 17535 } 17536 17537 var sv *TagResourceOutput 17538 if *v == nil { 17539 sv = &TagResourceOutput{} 17540 } else { 17541 sv = *v 17542 } 17543 17544 for key, value := range shape { 17545 switch key { 17546 default: 17547 _, _ = key, value 17548 17549 } 17550 } 17551 *v = sv 17552 return nil 17553} 17554 17555func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 17556 if v == nil { 17557 return fmt.Errorf("unexpected nil of type %T", v) 17558 } 17559 if value == nil { 17560 return nil 17561 } 17562 17563 shape, ok := value.(map[string]interface{}) 17564 if !ok { 17565 return fmt.Errorf("unexpected JSON type %v", value) 17566 } 17567 17568 var sv *UntagResourceOutput 17569 if *v == nil { 17570 sv = &UntagResourceOutput{} 17571 } else { 17572 sv = *v 17573 } 17574 17575 for key, value := range shape { 17576 switch key { 17577 default: 17578 _, _ = key, value 17579 17580 } 17581 } 17582 *v = sv 17583 return nil 17584} 17585 17586func awsAwsjson11_deserializeOpDocumentUpdateCapacityProviderOutput(v **UpdateCapacityProviderOutput, value interface{}) error { 17587 if v == nil { 17588 return fmt.Errorf("unexpected nil of type %T", v) 17589 } 17590 if value == nil { 17591 return nil 17592 } 17593 17594 shape, ok := value.(map[string]interface{}) 17595 if !ok { 17596 return fmt.Errorf("unexpected JSON type %v", value) 17597 } 17598 17599 var sv *UpdateCapacityProviderOutput 17600 if *v == nil { 17601 sv = &UpdateCapacityProviderOutput{} 17602 } else { 17603 sv = *v 17604 } 17605 17606 for key, value := range shape { 17607 switch key { 17608 case "capacityProvider": 17609 if err := awsAwsjson11_deserializeDocumentCapacityProvider(&sv.CapacityProvider, value); err != nil { 17610 return err 17611 } 17612 17613 default: 17614 _, _ = key, value 17615 17616 } 17617 } 17618 *v = sv 17619 return nil 17620} 17621 17622func awsAwsjson11_deserializeOpDocumentUpdateClusterOutput(v **UpdateClusterOutput, value interface{}) error { 17623 if v == nil { 17624 return fmt.Errorf("unexpected nil of type %T", v) 17625 } 17626 if value == nil { 17627 return nil 17628 } 17629 17630 shape, ok := value.(map[string]interface{}) 17631 if !ok { 17632 return fmt.Errorf("unexpected JSON type %v", value) 17633 } 17634 17635 var sv *UpdateClusterOutput 17636 if *v == nil { 17637 sv = &UpdateClusterOutput{} 17638 } else { 17639 sv = *v 17640 } 17641 17642 for key, value := range shape { 17643 switch key { 17644 case "cluster": 17645 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 17646 return err 17647 } 17648 17649 default: 17650 _, _ = key, value 17651 17652 } 17653 } 17654 *v = sv 17655 return nil 17656} 17657 17658func awsAwsjson11_deserializeOpDocumentUpdateClusterSettingsOutput(v **UpdateClusterSettingsOutput, value interface{}) error { 17659 if v == nil { 17660 return fmt.Errorf("unexpected nil of type %T", v) 17661 } 17662 if value == nil { 17663 return nil 17664 } 17665 17666 shape, ok := value.(map[string]interface{}) 17667 if !ok { 17668 return fmt.Errorf("unexpected JSON type %v", value) 17669 } 17670 17671 var sv *UpdateClusterSettingsOutput 17672 if *v == nil { 17673 sv = &UpdateClusterSettingsOutput{} 17674 } else { 17675 sv = *v 17676 } 17677 17678 for key, value := range shape { 17679 switch key { 17680 case "cluster": 17681 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 17682 return err 17683 } 17684 17685 default: 17686 _, _ = key, value 17687 17688 } 17689 } 17690 *v = sv 17691 return nil 17692} 17693 17694func awsAwsjson11_deserializeOpDocumentUpdateContainerAgentOutput(v **UpdateContainerAgentOutput, value interface{}) error { 17695 if v == nil { 17696 return fmt.Errorf("unexpected nil of type %T", v) 17697 } 17698 if value == nil { 17699 return nil 17700 } 17701 17702 shape, ok := value.(map[string]interface{}) 17703 if !ok { 17704 return fmt.Errorf("unexpected JSON type %v", value) 17705 } 17706 17707 var sv *UpdateContainerAgentOutput 17708 if *v == nil { 17709 sv = &UpdateContainerAgentOutput{} 17710 } else { 17711 sv = *v 17712 } 17713 17714 for key, value := range shape { 17715 switch key { 17716 case "containerInstance": 17717 if err := awsAwsjson11_deserializeDocumentContainerInstance(&sv.ContainerInstance, value); err != nil { 17718 return err 17719 } 17720 17721 default: 17722 _, _ = key, value 17723 17724 } 17725 } 17726 *v = sv 17727 return nil 17728} 17729 17730func awsAwsjson11_deserializeOpDocumentUpdateContainerInstancesStateOutput(v **UpdateContainerInstancesStateOutput, value interface{}) error { 17731 if v == nil { 17732 return fmt.Errorf("unexpected nil of type %T", v) 17733 } 17734 if value == nil { 17735 return nil 17736 } 17737 17738 shape, ok := value.(map[string]interface{}) 17739 if !ok { 17740 return fmt.Errorf("unexpected JSON type %v", value) 17741 } 17742 17743 var sv *UpdateContainerInstancesStateOutput 17744 if *v == nil { 17745 sv = &UpdateContainerInstancesStateOutput{} 17746 } else { 17747 sv = *v 17748 } 17749 17750 for key, value := range shape { 17751 switch key { 17752 case "containerInstances": 17753 if err := awsAwsjson11_deserializeDocumentContainerInstances(&sv.ContainerInstances, value); err != nil { 17754 return err 17755 } 17756 17757 case "failures": 17758 if err := awsAwsjson11_deserializeDocumentFailures(&sv.Failures, value); err != nil { 17759 return err 17760 } 17761 17762 default: 17763 _, _ = key, value 17764 17765 } 17766 } 17767 *v = sv 17768 return nil 17769} 17770 17771func awsAwsjson11_deserializeOpDocumentUpdateServiceOutput(v **UpdateServiceOutput, value interface{}) error { 17772 if v == nil { 17773 return fmt.Errorf("unexpected nil of type %T", v) 17774 } 17775 if value == nil { 17776 return nil 17777 } 17778 17779 shape, ok := value.(map[string]interface{}) 17780 if !ok { 17781 return fmt.Errorf("unexpected JSON type %v", value) 17782 } 17783 17784 var sv *UpdateServiceOutput 17785 if *v == nil { 17786 sv = &UpdateServiceOutput{} 17787 } else { 17788 sv = *v 17789 } 17790 17791 for key, value := range shape { 17792 switch key { 17793 case "service": 17794 if err := awsAwsjson11_deserializeDocumentService(&sv.Service, value); err != nil { 17795 return err 17796 } 17797 17798 default: 17799 _, _ = key, value 17800 17801 } 17802 } 17803 *v = sv 17804 return nil 17805} 17806 17807func awsAwsjson11_deserializeOpDocumentUpdateServicePrimaryTaskSetOutput(v **UpdateServicePrimaryTaskSetOutput, value interface{}) error { 17808 if v == nil { 17809 return fmt.Errorf("unexpected nil of type %T", v) 17810 } 17811 if value == nil { 17812 return nil 17813 } 17814 17815 shape, ok := value.(map[string]interface{}) 17816 if !ok { 17817 return fmt.Errorf("unexpected JSON type %v", value) 17818 } 17819 17820 var sv *UpdateServicePrimaryTaskSetOutput 17821 if *v == nil { 17822 sv = &UpdateServicePrimaryTaskSetOutput{} 17823 } else { 17824 sv = *v 17825 } 17826 17827 for key, value := range shape { 17828 switch key { 17829 case "taskSet": 17830 if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil { 17831 return err 17832 } 17833 17834 default: 17835 _, _ = key, value 17836 17837 } 17838 } 17839 *v = sv 17840 return nil 17841} 17842 17843func awsAwsjson11_deserializeOpDocumentUpdateTaskSetOutput(v **UpdateTaskSetOutput, value interface{}) error { 17844 if v == nil { 17845 return fmt.Errorf("unexpected nil of type %T", v) 17846 } 17847 if value == nil { 17848 return nil 17849 } 17850 17851 shape, ok := value.(map[string]interface{}) 17852 if !ok { 17853 return fmt.Errorf("unexpected JSON type %v", value) 17854 } 17855 17856 var sv *UpdateTaskSetOutput 17857 if *v == nil { 17858 sv = &UpdateTaskSetOutput{} 17859 } else { 17860 sv = *v 17861 } 17862 17863 for key, value := range shape { 17864 switch key { 17865 case "taskSet": 17866 if err := awsAwsjson11_deserializeDocumentTaskSet(&sv.TaskSet, value); err != nil { 17867 return err 17868 } 17869 17870 default: 17871 _, _ = key, value 17872 17873 } 17874 } 17875 *v = sv 17876 return nil 17877} 17878