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