1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotdeviceadvisor 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/iotdeviceadvisor/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsRestjson1_deserializeOpCreateSuiteDefinition struct { 23} 24 25func (*awsRestjson1_deserializeOpCreateSuiteDefinition) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpCreateSuiteDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorCreateSuiteDefinition(response, &metadata) 44 } 45 output := &CreateSuiteDefinitionOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsRestjson1_deserializeOpDocumentCreateSuiteDefinitionOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 return out, metadata, &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 } 75 76 return out, metadata, err 77} 78 79func awsRestjson1_deserializeOpErrorCreateSuiteDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("InternalServerException", errorCode): 121 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 122 123 case strings.EqualFold("ValidationException", errorCode): 124 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 125 126 default: 127 genericError := &smithy.GenericAPIError{ 128 Code: errorCode, 129 Message: errorMessage, 130 } 131 return genericError 132 133 } 134} 135 136func awsRestjson1_deserializeOpDocumentCreateSuiteDefinitionOutput(v **CreateSuiteDefinitionOutput, value interface{}) error { 137 if v == nil { 138 return fmt.Errorf("unexpected nil of type %T", v) 139 } 140 if value == nil { 141 return nil 142 } 143 144 shape, ok := value.(map[string]interface{}) 145 if !ok { 146 return fmt.Errorf("unexpected JSON type %v", value) 147 } 148 149 var sv *CreateSuiteDefinitionOutput 150 if *v == nil { 151 sv = &CreateSuiteDefinitionOutput{} 152 } else { 153 sv = *v 154 } 155 156 for key, value := range shape { 157 switch key { 158 case "createdAt": 159 if value != nil { 160 switch jtv := value.(type) { 161 case json.Number: 162 f64, err := jtv.Float64() 163 if err != nil { 164 return err 165 } 166 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 167 168 default: 169 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 170 171 } 172 } 173 174 case "suiteDefinitionArn": 175 if value != nil { 176 jtv, ok := value.(string) 177 if !ok { 178 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 179 } 180 sv.SuiteDefinitionArn = ptr.String(jtv) 181 } 182 183 case "suiteDefinitionId": 184 if value != nil { 185 jtv, ok := value.(string) 186 if !ok { 187 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 188 } 189 sv.SuiteDefinitionId = ptr.String(jtv) 190 } 191 192 case "suiteDefinitionName": 193 if value != nil { 194 jtv, ok := value.(string) 195 if !ok { 196 return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value) 197 } 198 sv.SuiteDefinitionName = ptr.String(jtv) 199 } 200 201 default: 202 _, _ = key, value 203 204 } 205 } 206 *v = sv 207 return nil 208} 209 210type awsRestjson1_deserializeOpDeleteSuiteDefinition struct { 211} 212 213func (*awsRestjson1_deserializeOpDeleteSuiteDefinition) ID() string { 214 return "OperationDeserializer" 215} 216 217func (m *awsRestjson1_deserializeOpDeleteSuiteDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 218 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 219) { 220 out, metadata, err = next.HandleDeserialize(ctx, in) 221 if err != nil { 222 return out, metadata, err 223 } 224 225 response, ok := out.RawResponse.(*smithyhttp.Response) 226 if !ok { 227 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 228 } 229 230 if response.StatusCode < 200 || response.StatusCode >= 300 { 231 return out, metadata, awsRestjson1_deserializeOpErrorDeleteSuiteDefinition(response, &metadata) 232 } 233 output := &DeleteSuiteDefinitionOutput{} 234 out.Result = output 235 236 return out, metadata, err 237} 238 239func awsRestjson1_deserializeOpErrorDeleteSuiteDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 240 var errorBuffer bytes.Buffer 241 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 242 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 243 } 244 errorBody := bytes.NewReader(errorBuffer.Bytes()) 245 246 errorCode := "UnknownError" 247 errorMessage := errorCode 248 249 code := response.Header.Get("X-Amzn-ErrorType") 250 if len(code) != 0 { 251 errorCode = restjson.SanitizeErrorCode(code) 252 } 253 254 var buff [1024]byte 255 ringBuffer := smithyio.NewRingBuffer(buff[:]) 256 257 body := io.TeeReader(errorBody, ringBuffer) 258 decoder := json.NewDecoder(body) 259 decoder.UseNumber() 260 code, message, err := restjson.GetErrorInfo(decoder) 261 if err != nil { 262 var snapshot bytes.Buffer 263 io.Copy(&snapshot, ringBuffer) 264 err = &smithy.DeserializationError{ 265 Err: fmt.Errorf("failed to decode response body, %w", err), 266 Snapshot: snapshot.Bytes(), 267 } 268 return err 269 } 270 271 errorBody.Seek(0, io.SeekStart) 272 if len(code) != 0 { 273 errorCode = restjson.SanitizeErrorCode(code) 274 } 275 if len(message) != 0 { 276 errorMessage = message 277 } 278 279 switch { 280 case strings.EqualFold("InternalServerException", errorCode): 281 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 282 283 case strings.EqualFold("ValidationException", errorCode): 284 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 285 286 default: 287 genericError := &smithy.GenericAPIError{ 288 Code: errorCode, 289 Message: errorMessage, 290 } 291 return genericError 292 293 } 294} 295 296type awsRestjson1_deserializeOpGetSuiteDefinition struct { 297} 298 299func (*awsRestjson1_deserializeOpGetSuiteDefinition) ID() string { 300 return "OperationDeserializer" 301} 302 303func (m *awsRestjson1_deserializeOpGetSuiteDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 304 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 305) { 306 out, metadata, err = next.HandleDeserialize(ctx, in) 307 if err != nil { 308 return out, metadata, err 309 } 310 311 response, ok := out.RawResponse.(*smithyhttp.Response) 312 if !ok { 313 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 314 } 315 316 if response.StatusCode < 200 || response.StatusCode >= 300 { 317 return out, metadata, awsRestjson1_deserializeOpErrorGetSuiteDefinition(response, &metadata) 318 } 319 output := &GetSuiteDefinitionOutput{} 320 out.Result = output 321 322 var buff [1024]byte 323 ringBuffer := smithyio.NewRingBuffer(buff[:]) 324 325 body := io.TeeReader(response.Body, ringBuffer) 326 327 decoder := json.NewDecoder(body) 328 decoder.UseNumber() 329 var shape interface{} 330 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 331 var snapshot bytes.Buffer 332 io.Copy(&snapshot, ringBuffer) 333 err = &smithy.DeserializationError{ 334 Err: fmt.Errorf("failed to decode response body, %w", err), 335 Snapshot: snapshot.Bytes(), 336 } 337 return out, metadata, err 338 } 339 340 err = awsRestjson1_deserializeOpDocumentGetSuiteDefinitionOutput(&output, shape) 341 if err != nil { 342 var snapshot bytes.Buffer 343 io.Copy(&snapshot, ringBuffer) 344 return out, metadata, &smithy.DeserializationError{ 345 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 346 Snapshot: snapshot.Bytes(), 347 } 348 } 349 350 return out, metadata, err 351} 352 353func awsRestjson1_deserializeOpErrorGetSuiteDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 354 var errorBuffer bytes.Buffer 355 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 356 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 357 } 358 errorBody := bytes.NewReader(errorBuffer.Bytes()) 359 360 errorCode := "UnknownError" 361 errorMessage := errorCode 362 363 code := response.Header.Get("X-Amzn-ErrorType") 364 if len(code) != 0 { 365 errorCode = restjson.SanitizeErrorCode(code) 366 } 367 368 var buff [1024]byte 369 ringBuffer := smithyio.NewRingBuffer(buff[:]) 370 371 body := io.TeeReader(errorBody, ringBuffer) 372 decoder := json.NewDecoder(body) 373 decoder.UseNumber() 374 code, message, err := restjson.GetErrorInfo(decoder) 375 if err != nil { 376 var snapshot bytes.Buffer 377 io.Copy(&snapshot, ringBuffer) 378 err = &smithy.DeserializationError{ 379 Err: fmt.Errorf("failed to decode response body, %w", err), 380 Snapshot: snapshot.Bytes(), 381 } 382 return err 383 } 384 385 errorBody.Seek(0, io.SeekStart) 386 if len(code) != 0 { 387 errorCode = restjson.SanitizeErrorCode(code) 388 } 389 if len(message) != 0 { 390 errorMessage = message 391 } 392 393 switch { 394 case strings.EqualFold("InternalServerException", errorCode): 395 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 396 397 case strings.EqualFold("ResourceNotFoundException", errorCode): 398 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 399 400 case strings.EqualFold("ValidationException", errorCode): 401 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 402 403 default: 404 genericError := &smithy.GenericAPIError{ 405 Code: errorCode, 406 Message: errorMessage, 407 } 408 return genericError 409 410 } 411} 412 413func awsRestjson1_deserializeOpDocumentGetSuiteDefinitionOutput(v **GetSuiteDefinitionOutput, value interface{}) error { 414 if v == nil { 415 return fmt.Errorf("unexpected nil of type %T", v) 416 } 417 if value == nil { 418 return nil 419 } 420 421 shape, ok := value.(map[string]interface{}) 422 if !ok { 423 return fmt.Errorf("unexpected JSON type %v", value) 424 } 425 426 var sv *GetSuiteDefinitionOutput 427 if *v == nil { 428 sv = &GetSuiteDefinitionOutput{} 429 } else { 430 sv = *v 431 } 432 433 for key, value := range shape { 434 switch key { 435 case "createdAt": 436 if value != nil { 437 switch jtv := value.(type) { 438 case json.Number: 439 f64, err := jtv.Float64() 440 if err != nil { 441 return err 442 } 443 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 444 445 default: 446 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 447 448 } 449 } 450 451 case "lastModifiedAt": 452 if value != nil { 453 switch jtv := value.(type) { 454 case json.Number: 455 f64, err := jtv.Float64() 456 if err != nil { 457 return err 458 } 459 sv.LastModifiedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 460 461 default: 462 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 463 464 } 465 } 466 467 case "latestVersion": 468 if value != nil { 469 jtv, ok := value.(string) 470 if !ok { 471 return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value) 472 } 473 sv.LatestVersion = ptr.String(jtv) 474 } 475 476 case "suiteDefinitionArn": 477 if value != nil { 478 jtv, ok := value.(string) 479 if !ok { 480 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 481 } 482 sv.SuiteDefinitionArn = ptr.String(jtv) 483 } 484 485 case "suiteDefinitionConfiguration": 486 if err := awsRestjson1_deserializeDocumentSuiteDefinitionConfiguration(&sv.SuiteDefinitionConfiguration, value); err != nil { 487 return err 488 } 489 490 case "suiteDefinitionId": 491 if value != nil { 492 jtv, ok := value.(string) 493 if !ok { 494 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 495 } 496 sv.SuiteDefinitionId = ptr.String(jtv) 497 } 498 499 case "suiteDefinitionVersion": 500 if value != nil { 501 jtv, ok := value.(string) 502 if !ok { 503 return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value) 504 } 505 sv.SuiteDefinitionVersion = ptr.String(jtv) 506 } 507 508 case "tags": 509 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 510 return err 511 } 512 513 default: 514 _, _ = key, value 515 516 } 517 } 518 *v = sv 519 return nil 520} 521 522type awsRestjson1_deserializeOpGetSuiteRun struct { 523} 524 525func (*awsRestjson1_deserializeOpGetSuiteRun) ID() string { 526 return "OperationDeserializer" 527} 528 529func (m *awsRestjson1_deserializeOpGetSuiteRun) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 530 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 531) { 532 out, metadata, err = next.HandleDeserialize(ctx, in) 533 if err != nil { 534 return out, metadata, err 535 } 536 537 response, ok := out.RawResponse.(*smithyhttp.Response) 538 if !ok { 539 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 540 } 541 542 if response.StatusCode < 200 || response.StatusCode >= 300 { 543 return out, metadata, awsRestjson1_deserializeOpErrorGetSuiteRun(response, &metadata) 544 } 545 output := &GetSuiteRunOutput{} 546 out.Result = output 547 548 var buff [1024]byte 549 ringBuffer := smithyio.NewRingBuffer(buff[:]) 550 551 body := io.TeeReader(response.Body, ringBuffer) 552 553 decoder := json.NewDecoder(body) 554 decoder.UseNumber() 555 var shape interface{} 556 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 557 var snapshot bytes.Buffer 558 io.Copy(&snapshot, ringBuffer) 559 err = &smithy.DeserializationError{ 560 Err: fmt.Errorf("failed to decode response body, %w", err), 561 Snapshot: snapshot.Bytes(), 562 } 563 return out, metadata, err 564 } 565 566 err = awsRestjson1_deserializeOpDocumentGetSuiteRunOutput(&output, shape) 567 if err != nil { 568 var snapshot bytes.Buffer 569 io.Copy(&snapshot, ringBuffer) 570 return out, metadata, &smithy.DeserializationError{ 571 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 572 Snapshot: snapshot.Bytes(), 573 } 574 } 575 576 return out, metadata, err 577} 578 579func awsRestjson1_deserializeOpErrorGetSuiteRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { 580 var errorBuffer bytes.Buffer 581 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 582 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 583 } 584 errorBody := bytes.NewReader(errorBuffer.Bytes()) 585 586 errorCode := "UnknownError" 587 errorMessage := errorCode 588 589 code := response.Header.Get("X-Amzn-ErrorType") 590 if len(code) != 0 { 591 errorCode = restjson.SanitizeErrorCode(code) 592 } 593 594 var buff [1024]byte 595 ringBuffer := smithyio.NewRingBuffer(buff[:]) 596 597 body := io.TeeReader(errorBody, ringBuffer) 598 decoder := json.NewDecoder(body) 599 decoder.UseNumber() 600 code, message, err := restjson.GetErrorInfo(decoder) 601 if err != nil { 602 var snapshot bytes.Buffer 603 io.Copy(&snapshot, ringBuffer) 604 err = &smithy.DeserializationError{ 605 Err: fmt.Errorf("failed to decode response body, %w", err), 606 Snapshot: snapshot.Bytes(), 607 } 608 return err 609 } 610 611 errorBody.Seek(0, io.SeekStart) 612 if len(code) != 0 { 613 errorCode = restjson.SanitizeErrorCode(code) 614 } 615 if len(message) != 0 { 616 errorMessage = message 617 } 618 619 switch { 620 case strings.EqualFold("InternalServerException", errorCode): 621 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 622 623 case strings.EqualFold("ResourceNotFoundException", errorCode): 624 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 625 626 case strings.EqualFold("ValidationException", errorCode): 627 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 628 629 default: 630 genericError := &smithy.GenericAPIError{ 631 Code: errorCode, 632 Message: errorMessage, 633 } 634 return genericError 635 636 } 637} 638 639func awsRestjson1_deserializeOpDocumentGetSuiteRunOutput(v **GetSuiteRunOutput, value interface{}) error { 640 if v == nil { 641 return fmt.Errorf("unexpected nil of type %T", v) 642 } 643 if value == nil { 644 return nil 645 } 646 647 shape, ok := value.(map[string]interface{}) 648 if !ok { 649 return fmt.Errorf("unexpected JSON type %v", value) 650 } 651 652 var sv *GetSuiteRunOutput 653 if *v == nil { 654 sv = &GetSuiteRunOutput{} 655 } else { 656 sv = *v 657 } 658 659 for key, value := range shape { 660 switch key { 661 case "endTime": 662 if value != nil { 663 switch jtv := value.(type) { 664 case json.Number: 665 f64, err := jtv.Float64() 666 if err != nil { 667 return err 668 } 669 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 670 671 default: 672 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 673 674 } 675 } 676 677 case "errorReason": 678 if value != nil { 679 jtv, ok := value.(string) 680 if !ok { 681 return fmt.Errorf("expected ErrorReason to be of type string, got %T instead", value) 682 } 683 sv.ErrorReason = ptr.String(jtv) 684 } 685 686 case "startTime": 687 if value != nil { 688 switch jtv := value.(type) { 689 case json.Number: 690 f64, err := jtv.Float64() 691 if err != nil { 692 return err 693 } 694 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 695 696 default: 697 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 698 699 } 700 } 701 702 case "status": 703 if value != nil { 704 jtv, ok := value.(string) 705 if !ok { 706 return fmt.Errorf("expected SuiteRunStatus to be of type string, got %T instead", value) 707 } 708 sv.Status = types.SuiteRunStatus(jtv) 709 } 710 711 case "suiteDefinitionId": 712 if value != nil { 713 jtv, ok := value.(string) 714 if !ok { 715 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 716 } 717 sv.SuiteDefinitionId = ptr.String(jtv) 718 } 719 720 case "suiteDefinitionVersion": 721 if value != nil { 722 jtv, ok := value.(string) 723 if !ok { 724 return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value) 725 } 726 sv.SuiteDefinitionVersion = ptr.String(jtv) 727 } 728 729 case "suiteRunArn": 730 if value != nil { 731 jtv, ok := value.(string) 732 if !ok { 733 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 734 } 735 sv.SuiteRunArn = ptr.String(jtv) 736 } 737 738 case "suiteRunConfiguration": 739 if err := awsRestjson1_deserializeDocumentSuiteRunConfiguration(&sv.SuiteRunConfiguration, value); err != nil { 740 return err 741 } 742 743 case "suiteRunId": 744 if value != nil { 745 jtv, ok := value.(string) 746 if !ok { 747 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 748 } 749 sv.SuiteRunId = ptr.String(jtv) 750 } 751 752 case "tags": 753 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 754 return err 755 } 756 757 case "testResult": 758 if err := awsRestjson1_deserializeDocumentTestResult(&sv.TestResult, value); err != nil { 759 return err 760 } 761 762 default: 763 _, _ = key, value 764 765 } 766 } 767 *v = sv 768 return nil 769} 770 771type awsRestjson1_deserializeOpGetSuiteRunReport struct { 772} 773 774func (*awsRestjson1_deserializeOpGetSuiteRunReport) ID() string { 775 return "OperationDeserializer" 776} 777 778func (m *awsRestjson1_deserializeOpGetSuiteRunReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 779 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 780) { 781 out, metadata, err = next.HandleDeserialize(ctx, in) 782 if err != nil { 783 return out, metadata, err 784 } 785 786 response, ok := out.RawResponse.(*smithyhttp.Response) 787 if !ok { 788 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 789 } 790 791 if response.StatusCode < 200 || response.StatusCode >= 300 { 792 return out, metadata, awsRestjson1_deserializeOpErrorGetSuiteRunReport(response, &metadata) 793 } 794 output := &GetSuiteRunReportOutput{} 795 out.Result = output 796 797 var buff [1024]byte 798 ringBuffer := smithyio.NewRingBuffer(buff[:]) 799 800 body := io.TeeReader(response.Body, ringBuffer) 801 802 decoder := json.NewDecoder(body) 803 decoder.UseNumber() 804 var shape interface{} 805 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 806 var snapshot bytes.Buffer 807 io.Copy(&snapshot, ringBuffer) 808 err = &smithy.DeserializationError{ 809 Err: fmt.Errorf("failed to decode response body, %w", err), 810 Snapshot: snapshot.Bytes(), 811 } 812 return out, metadata, err 813 } 814 815 err = awsRestjson1_deserializeOpDocumentGetSuiteRunReportOutput(&output, shape) 816 if err != nil { 817 var snapshot bytes.Buffer 818 io.Copy(&snapshot, ringBuffer) 819 return out, metadata, &smithy.DeserializationError{ 820 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 821 Snapshot: snapshot.Bytes(), 822 } 823 } 824 825 return out, metadata, err 826} 827 828func awsRestjson1_deserializeOpErrorGetSuiteRunReport(response *smithyhttp.Response, metadata *middleware.Metadata) error { 829 var errorBuffer bytes.Buffer 830 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 831 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 832 } 833 errorBody := bytes.NewReader(errorBuffer.Bytes()) 834 835 errorCode := "UnknownError" 836 errorMessage := errorCode 837 838 code := response.Header.Get("X-Amzn-ErrorType") 839 if len(code) != 0 { 840 errorCode = restjson.SanitizeErrorCode(code) 841 } 842 843 var buff [1024]byte 844 ringBuffer := smithyio.NewRingBuffer(buff[:]) 845 846 body := io.TeeReader(errorBody, ringBuffer) 847 decoder := json.NewDecoder(body) 848 decoder.UseNumber() 849 code, message, err := restjson.GetErrorInfo(decoder) 850 if err != nil { 851 var snapshot bytes.Buffer 852 io.Copy(&snapshot, ringBuffer) 853 err = &smithy.DeserializationError{ 854 Err: fmt.Errorf("failed to decode response body, %w", err), 855 Snapshot: snapshot.Bytes(), 856 } 857 return err 858 } 859 860 errorBody.Seek(0, io.SeekStart) 861 if len(code) != 0 { 862 errorCode = restjson.SanitizeErrorCode(code) 863 } 864 if len(message) != 0 { 865 errorMessage = message 866 } 867 868 switch { 869 case strings.EqualFold("InternalServerException", errorCode): 870 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 871 872 case strings.EqualFold("ResourceNotFoundException", errorCode): 873 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 874 875 case strings.EqualFold("ValidationException", errorCode): 876 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 877 878 default: 879 genericError := &smithy.GenericAPIError{ 880 Code: errorCode, 881 Message: errorMessage, 882 } 883 return genericError 884 885 } 886} 887 888func awsRestjson1_deserializeOpDocumentGetSuiteRunReportOutput(v **GetSuiteRunReportOutput, value interface{}) error { 889 if v == nil { 890 return fmt.Errorf("unexpected nil of type %T", v) 891 } 892 if value == nil { 893 return nil 894 } 895 896 shape, ok := value.(map[string]interface{}) 897 if !ok { 898 return fmt.Errorf("unexpected JSON type %v", value) 899 } 900 901 var sv *GetSuiteRunReportOutput 902 if *v == nil { 903 sv = &GetSuiteRunReportOutput{} 904 } else { 905 sv = *v 906 } 907 908 for key, value := range shape { 909 switch key { 910 case "qualificationReportDownloadUrl": 911 if value != nil { 912 jtv, ok := value.(string) 913 if !ok { 914 return fmt.Errorf("expected QualificationReportDownloadUrl to be of type string, got %T instead", value) 915 } 916 sv.QualificationReportDownloadUrl = ptr.String(jtv) 917 } 918 919 default: 920 _, _ = key, value 921 922 } 923 } 924 *v = sv 925 return nil 926} 927 928type awsRestjson1_deserializeOpListSuiteDefinitions struct { 929} 930 931func (*awsRestjson1_deserializeOpListSuiteDefinitions) ID() string { 932 return "OperationDeserializer" 933} 934 935func (m *awsRestjson1_deserializeOpListSuiteDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 936 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 937) { 938 out, metadata, err = next.HandleDeserialize(ctx, in) 939 if err != nil { 940 return out, metadata, err 941 } 942 943 response, ok := out.RawResponse.(*smithyhttp.Response) 944 if !ok { 945 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 946 } 947 948 if response.StatusCode < 200 || response.StatusCode >= 300 { 949 return out, metadata, awsRestjson1_deserializeOpErrorListSuiteDefinitions(response, &metadata) 950 } 951 output := &ListSuiteDefinitionsOutput{} 952 out.Result = output 953 954 var buff [1024]byte 955 ringBuffer := smithyio.NewRingBuffer(buff[:]) 956 957 body := io.TeeReader(response.Body, ringBuffer) 958 959 decoder := json.NewDecoder(body) 960 decoder.UseNumber() 961 var shape interface{} 962 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 963 var snapshot bytes.Buffer 964 io.Copy(&snapshot, ringBuffer) 965 err = &smithy.DeserializationError{ 966 Err: fmt.Errorf("failed to decode response body, %w", err), 967 Snapshot: snapshot.Bytes(), 968 } 969 return out, metadata, err 970 } 971 972 err = awsRestjson1_deserializeOpDocumentListSuiteDefinitionsOutput(&output, shape) 973 if err != nil { 974 var snapshot bytes.Buffer 975 io.Copy(&snapshot, ringBuffer) 976 return out, metadata, &smithy.DeserializationError{ 977 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 978 Snapshot: snapshot.Bytes(), 979 } 980 } 981 982 return out, metadata, err 983} 984 985func awsRestjson1_deserializeOpErrorListSuiteDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 986 var errorBuffer bytes.Buffer 987 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 988 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 989 } 990 errorBody := bytes.NewReader(errorBuffer.Bytes()) 991 992 errorCode := "UnknownError" 993 errorMessage := errorCode 994 995 code := response.Header.Get("X-Amzn-ErrorType") 996 if len(code) != 0 { 997 errorCode = restjson.SanitizeErrorCode(code) 998 } 999 1000 var buff [1024]byte 1001 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1002 1003 body := io.TeeReader(errorBody, ringBuffer) 1004 decoder := json.NewDecoder(body) 1005 decoder.UseNumber() 1006 code, message, err := restjson.GetErrorInfo(decoder) 1007 if err != nil { 1008 var snapshot bytes.Buffer 1009 io.Copy(&snapshot, ringBuffer) 1010 err = &smithy.DeserializationError{ 1011 Err: fmt.Errorf("failed to decode response body, %w", err), 1012 Snapshot: snapshot.Bytes(), 1013 } 1014 return err 1015 } 1016 1017 errorBody.Seek(0, io.SeekStart) 1018 if len(code) != 0 { 1019 errorCode = restjson.SanitizeErrorCode(code) 1020 } 1021 if len(message) != 0 { 1022 errorMessage = message 1023 } 1024 1025 switch { 1026 case strings.EqualFold("InternalServerException", errorCode): 1027 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1028 1029 case strings.EqualFold("ValidationException", errorCode): 1030 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1031 1032 default: 1033 genericError := &smithy.GenericAPIError{ 1034 Code: errorCode, 1035 Message: errorMessage, 1036 } 1037 return genericError 1038 1039 } 1040} 1041 1042func awsRestjson1_deserializeOpDocumentListSuiteDefinitionsOutput(v **ListSuiteDefinitionsOutput, value interface{}) error { 1043 if v == nil { 1044 return fmt.Errorf("unexpected nil of type %T", v) 1045 } 1046 if value == nil { 1047 return nil 1048 } 1049 1050 shape, ok := value.(map[string]interface{}) 1051 if !ok { 1052 return fmt.Errorf("unexpected JSON type %v", value) 1053 } 1054 1055 var sv *ListSuiteDefinitionsOutput 1056 if *v == nil { 1057 sv = &ListSuiteDefinitionsOutput{} 1058 } else { 1059 sv = *v 1060 } 1061 1062 for key, value := range shape { 1063 switch key { 1064 case "nextToken": 1065 if value != nil { 1066 jtv, ok := value.(string) 1067 if !ok { 1068 return fmt.Errorf("expected Token to be of type string, got %T instead", value) 1069 } 1070 sv.NextToken = ptr.String(jtv) 1071 } 1072 1073 case "suiteDefinitionInformationList": 1074 if err := awsRestjson1_deserializeDocumentSuiteDefinitionInformationList(&sv.SuiteDefinitionInformationList, value); err != nil { 1075 return err 1076 } 1077 1078 default: 1079 _, _ = key, value 1080 1081 } 1082 } 1083 *v = sv 1084 return nil 1085} 1086 1087type awsRestjson1_deserializeOpListSuiteRuns struct { 1088} 1089 1090func (*awsRestjson1_deserializeOpListSuiteRuns) ID() string { 1091 return "OperationDeserializer" 1092} 1093 1094func (m *awsRestjson1_deserializeOpListSuiteRuns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1095 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1096) { 1097 out, metadata, err = next.HandleDeserialize(ctx, in) 1098 if err != nil { 1099 return out, metadata, err 1100 } 1101 1102 response, ok := out.RawResponse.(*smithyhttp.Response) 1103 if !ok { 1104 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1105 } 1106 1107 if response.StatusCode < 200 || response.StatusCode >= 300 { 1108 return out, metadata, awsRestjson1_deserializeOpErrorListSuiteRuns(response, &metadata) 1109 } 1110 output := &ListSuiteRunsOutput{} 1111 out.Result = output 1112 1113 var buff [1024]byte 1114 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1115 1116 body := io.TeeReader(response.Body, ringBuffer) 1117 1118 decoder := json.NewDecoder(body) 1119 decoder.UseNumber() 1120 var shape interface{} 1121 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1122 var snapshot bytes.Buffer 1123 io.Copy(&snapshot, ringBuffer) 1124 err = &smithy.DeserializationError{ 1125 Err: fmt.Errorf("failed to decode response body, %w", err), 1126 Snapshot: snapshot.Bytes(), 1127 } 1128 return out, metadata, err 1129 } 1130 1131 err = awsRestjson1_deserializeOpDocumentListSuiteRunsOutput(&output, shape) 1132 if err != nil { 1133 var snapshot bytes.Buffer 1134 io.Copy(&snapshot, ringBuffer) 1135 return out, metadata, &smithy.DeserializationError{ 1136 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1137 Snapshot: snapshot.Bytes(), 1138 } 1139 } 1140 1141 return out, metadata, err 1142} 1143 1144func awsRestjson1_deserializeOpErrorListSuiteRuns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1145 var errorBuffer bytes.Buffer 1146 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1147 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1148 } 1149 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1150 1151 errorCode := "UnknownError" 1152 errorMessage := errorCode 1153 1154 code := response.Header.Get("X-Amzn-ErrorType") 1155 if len(code) != 0 { 1156 errorCode = restjson.SanitizeErrorCode(code) 1157 } 1158 1159 var buff [1024]byte 1160 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1161 1162 body := io.TeeReader(errorBody, ringBuffer) 1163 decoder := json.NewDecoder(body) 1164 decoder.UseNumber() 1165 code, message, err := restjson.GetErrorInfo(decoder) 1166 if err != nil { 1167 var snapshot bytes.Buffer 1168 io.Copy(&snapshot, ringBuffer) 1169 err = &smithy.DeserializationError{ 1170 Err: fmt.Errorf("failed to decode response body, %w", err), 1171 Snapshot: snapshot.Bytes(), 1172 } 1173 return err 1174 } 1175 1176 errorBody.Seek(0, io.SeekStart) 1177 if len(code) != 0 { 1178 errorCode = restjson.SanitizeErrorCode(code) 1179 } 1180 if len(message) != 0 { 1181 errorMessage = message 1182 } 1183 1184 switch { 1185 case strings.EqualFold("InternalServerException", errorCode): 1186 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1187 1188 case strings.EqualFold("ValidationException", errorCode): 1189 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1190 1191 default: 1192 genericError := &smithy.GenericAPIError{ 1193 Code: errorCode, 1194 Message: errorMessage, 1195 } 1196 return genericError 1197 1198 } 1199} 1200 1201func awsRestjson1_deserializeOpDocumentListSuiteRunsOutput(v **ListSuiteRunsOutput, value interface{}) error { 1202 if v == nil { 1203 return fmt.Errorf("unexpected nil of type %T", v) 1204 } 1205 if value == nil { 1206 return nil 1207 } 1208 1209 shape, ok := value.(map[string]interface{}) 1210 if !ok { 1211 return fmt.Errorf("unexpected JSON type %v", value) 1212 } 1213 1214 var sv *ListSuiteRunsOutput 1215 if *v == nil { 1216 sv = &ListSuiteRunsOutput{} 1217 } else { 1218 sv = *v 1219 } 1220 1221 for key, value := range shape { 1222 switch key { 1223 case "nextToken": 1224 if value != nil { 1225 jtv, ok := value.(string) 1226 if !ok { 1227 return fmt.Errorf("expected Token to be of type string, got %T instead", value) 1228 } 1229 sv.NextToken = ptr.String(jtv) 1230 } 1231 1232 case "suiteRunsList": 1233 if err := awsRestjson1_deserializeDocumentSuiteRunsList(&sv.SuiteRunsList, value); err != nil { 1234 return err 1235 } 1236 1237 default: 1238 _, _ = key, value 1239 1240 } 1241 } 1242 *v = sv 1243 return nil 1244} 1245 1246type awsRestjson1_deserializeOpListTagsForResource struct { 1247} 1248 1249func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 1250 return "OperationDeserializer" 1251} 1252 1253func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1254 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1255) { 1256 out, metadata, err = next.HandleDeserialize(ctx, in) 1257 if err != nil { 1258 return out, metadata, err 1259 } 1260 1261 response, ok := out.RawResponse.(*smithyhttp.Response) 1262 if !ok { 1263 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1264 } 1265 1266 if response.StatusCode < 200 || response.StatusCode >= 300 { 1267 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 1268 } 1269 output := &ListTagsForResourceOutput{} 1270 out.Result = output 1271 1272 var buff [1024]byte 1273 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1274 1275 body := io.TeeReader(response.Body, ringBuffer) 1276 1277 decoder := json.NewDecoder(body) 1278 decoder.UseNumber() 1279 var shape interface{} 1280 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1281 var snapshot bytes.Buffer 1282 io.Copy(&snapshot, ringBuffer) 1283 err = &smithy.DeserializationError{ 1284 Err: fmt.Errorf("failed to decode response body, %w", err), 1285 Snapshot: snapshot.Bytes(), 1286 } 1287 return out, metadata, err 1288 } 1289 1290 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 1291 if err != nil { 1292 var snapshot bytes.Buffer 1293 io.Copy(&snapshot, ringBuffer) 1294 return out, metadata, &smithy.DeserializationError{ 1295 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1296 Snapshot: snapshot.Bytes(), 1297 } 1298 } 1299 1300 return out, metadata, err 1301} 1302 1303func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1304 var errorBuffer bytes.Buffer 1305 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1306 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1307 } 1308 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1309 1310 errorCode := "UnknownError" 1311 errorMessage := errorCode 1312 1313 code := response.Header.Get("X-Amzn-ErrorType") 1314 if len(code) != 0 { 1315 errorCode = restjson.SanitizeErrorCode(code) 1316 } 1317 1318 var buff [1024]byte 1319 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1320 1321 body := io.TeeReader(errorBody, ringBuffer) 1322 decoder := json.NewDecoder(body) 1323 decoder.UseNumber() 1324 code, message, err := restjson.GetErrorInfo(decoder) 1325 if err != nil { 1326 var snapshot bytes.Buffer 1327 io.Copy(&snapshot, ringBuffer) 1328 err = &smithy.DeserializationError{ 1329 Err: fmt.Errorf("failed to decode response body, %w", err), 1330 Snapshot: snapshot.Bytes(), 1331 } 1332 return err 1333 } 1334 1335 errorBody.Seek(0, io.SeekStart) 1336 if len(code) != 0 { 1337 errorCode = restjson.SanitizeErrorCode(code) 1338 } 1339 if len(message) != 0 { 1340 errorMessage = message 1341 } 1342 1343 switch { 1344 case strings.EqualFold("InternalServerException", errorCode): 1345 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1346 1347 case strings.EqualFold("ResourceNotFoundException", errorCode): 1348 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1349 1350 case strings.EqualFold("ValidationException", errorCode): 1351 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1352 1353 default: 1354 genericError := &smithy.GenericAPIError{ 1355 Code: errorCode, 1356 Message: errorMessage, 1357 } 1358 return genericError 1359 1360 } 1361} 1362 1363func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 1364 if v == nil { 1365 return fmt.Errorf("unexpected nil of type %T", v) 1366 } 1367 if value == nil { 1368 return nil 1369 } 1370 1371 shape, ok := value.(map[string]interface{}) 1372 if !ok { 1373 return fmt.Errorf("unexpected JSON type %v", value) 1374 } 1375 1376 var sv *ListTagsForResourceOutput 1377 if *v == nil { 1378 sv = &ListTagsForResourceOutput{} 1379 } else { 1380 sv = *v 1381 } 1382 1383 for key, value := range shape { 1384 switch key { 1385 case "tags": 1386 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 1387 return err 1388 } 1389 1390 default: 1391 _, _ = key, value 1392 1393 } 1394 } 1395 *v = sv 1396 return nil 1397} 1398 1399type awsRestjson1_deserializeOpStartSuiteRun struct { 1400} 1401 1402func (*awsRestjson1_deserializeOpStartSuiteRun) ID() string { 1403 return "OperationDeserializer" 1404} 1405 1406func (m *awsRestjson1_deserializeOpStartSuiteRun) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1407 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1408) { 1409 out, metadata, err = next.HandleDeserialize(ctx, in) 1410 if err != nil { 1411 return out, metadata, err 1412 } 1413 1414 response, ok := out.RawResponse.(*smithyhttp.Response) 1415 if !ok { 1416 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1417 } 1418 1419 if response.StatusCode < 200 || response.StatusCode >= 300 { 1420 return out, metadata, awsRestjson1_deserializeOpErrorStartSuiteRun(response, &metadata) 1421 } 1422 output := &StartSuiteRunOutput{} 1423 out.Result = output 1424 1425 var buff [1024]byte 1426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1427 1428 body := io.TeeReader(response.Body, ringBuffer) 1429 1430 decoder := json.NewDecoder(body) 1431 decoder.UseNumber() 1432 var shape interface{} 1433 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1434 var snapshot bytes.Buffer 1435 io.Copy(&snapshot, ringBuffer) 1436 err = &smithy.DeserializationError{ 1437 Err: fmt.Errorf("failed to decode response body, %w", err), 1438 Snapshot: snapshot.Bytes(), 1439 } 1440 return out, metadata, err 1441 } 1442 1443 err = awsRestjson1_deserializeOpDocumentStartSuiteRunOutput(&output, shape) 1444 if err != nil { 1445 var snapshot bytes.Buffer 1446 io.Copy(&snapshot, ringBuffer) 1447 return out, metadata, &smithy.DeserializationError{ 1448 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1449 Snapshot: snapshot.Bytes(), 1450 } 1451 } 1452 1453 return out, metadata, err 1454} 1455 1456func awsRestjson1_deserializeOpErrorStartSuiteRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1457 var errorBuffer bytes.Buffer 1458 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1459 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1460 } 1461 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1462 1463 errorCode := "UnknownError" 1464 errorMessage := errorCode 1465 1466 code := response.Header.Get("X-Amzn-ErrorType") 1467 if len(code) != 0 { 1468 errorCode = restjson.SanitizeErrorCode(code) 1469 } 1470 1471 var buff [1024]byte 1472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1473 1474 body := io.TeeReader(errorBody, ringBuffer) 1475 decoder := json.NewDecoder(body) 1476 decoder.UseNumber() 1477 code, message, err := restjson.GetErrorInfo(decoder) 1478 if err != nil { 1479 var snapshot bytes.Buffer 1480 io.Copy(&snapshot, ringBuffer) 1481 err = &smithy.DeserializationError{ 1482 Err: fmt.Errorf("failed to decode response body, %w", err), 1483 Snapshot: snapshot.Bytes(), 1484 } 1485 return err 1486 } 1487 1488 errorBody.Seek(0, io.SeekStart) 1489 if len(code) != 0 { 1490 errorCode = restjson.SanitizeErrorCode(code) 1491 } 1492 if len(message) != 0 { 1493 errorMessage = message 1494 } 1495 1496 switch { 1497 case strings.EqualFold("ConflictException", errorCode): 1498 return awsRestjson1_deserializeErrorConflictException(response, errorBody) 1499 1500 case strings.EqualFold("InternalServerException", errorCode): 1501 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1502 1503 case strings.EqualFold("ValidationException", errorCode): 1504 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1505 1506 default: 1507 genericError := &smithy.GenericAPIError{ 1508 Code: errorCode, 1509 Message: errorMessage, 1510 } 1511 return genericError 1512 1513 } 1514} 1515 1516func awsRestjson1_deserializeOpDocumentStartSuiteRunOutput(v **StartSuiteRunOutput, value interface{}) error { 1517 if v == nil { 1518 return fmt.Errorf("unexpected nil of type %T", v) 1519 } 1520 if value == nil { 1521 return nil 1522 } 1523 1524 shape, ok := value.(map[string]interface{}) 1525 if !ok { 1526 return fmt.Errorf("unexpected JSON type %v", value) 1527 } 1528 1529 var sv *StartSuiteRunOutput 1530 if *v == nil { 1531 sv = &StartSuiteRunOutput{} 1532 } else { 1533 sv = *v 1534 } 1535 1536 for key, value := range shape { 1537 switch key { 1538 case "createdAt": 1539 if value != nil { 1540 switch jtv := value.(type) { 1541 case json.Number: 1542 f64, err := jtv.Float64() 1543 if err != nil { 1544 return err 1545 } 1546 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1547 1548 default: 1549 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 1550 1551 } 1552 } 1553 1554 case "suiteRunArn": 1555 if value != nil { 1556 jtv, ok := value.(string) 1557 if !ok { 1558 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 1559 } 1560 sv.SuiteRunArn = ptr.String(jtv) 1561 } 1562 1563 case "suiteRunId": 1564 if value != nil { 1565 jtv, ok := value.(string) 1566 if !ok { 1567 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 1568 } 1569 sv.SuiteRunId = ptr.String(jtv) 1570 } 1571 1572 default: 1573 _, _ = key, value 1574 1575 } 1576 } 1577 *v = sv 1578 return nil 1579} 1580 1581type awsRestjson1_deserializeOpStopSuiteRun struct { 1582} 1583 1584func (*awsRestjson1_deserializeOpStopSuiteRun) ID() string { 1585 return "OperationDeserializer" 1586} 1587 1588func (m *awsRestjson1_deserializeOpStopSuiteRun) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1589 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1590) { 1591 out, metadata, err = next.HandleDeserialize(ctx, in) 1592 if err != nil { 1593 return out, metadata, err 1594 } 1595 1596 response, ok := out.RawResponse.(*smithyhttp.Response) 1597 if !ok { 1598 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1599 } 1600 1601 if response.StatusCode < 200 || response.StatusCode >= 300 { 1602 return out, metadata, awsRestjson1_deserializeOpErrorStopSuiteRun(response, &metadata) 1603 } 1604 output := &StopSuiteRunOutput{} 1605 out.Result = output 1606 1607 return out, metadata, err 1608} 1609 1610func awsRestjson1_deserializeOpErrorStopSuiteRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1611 var errorBuffer bytes.Buffer 1612 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1613 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1614 } 1615 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1616 1617 errorCode := "UnknownError" 1618 errorMessage := errorCode 1619 1620 code := response.Header.Get("X-Amzn-ErrorType") 1621 if len(code) != 0 { 1622 errorCode = restjson.SanitizeErrorCode(code) 1623 } 1624 1625 var buff [1024]byte 1626 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1627 1628 body := io.TeeReader(errorBody, ringBuffer) 1629 decoder := json.NewDecoder(body) 1630 decoder.UseNumber() 1631 code, message, err := restjson.GetErrorInfo(decoder) 1632 if err != nil { 1633 var snapshot bytes.Buffer 1634 io.Copy(&snapshot, ringBuffer) 1635 err = &smithy.DeserializationError{ 1636 Err: fmt.Errorf("failed to decode response body, %w", err), 1637 Snapshot: snapshot.Bytes(), 1638 } 1639 return err 1640 } 1641 1642 errorBody.Seek(0, io.SeekStart) 1643 if len(code) != 0 { 1644 errorCode = restjson.SanitizeErrorCode(code) 1645 } 1646 if len(message) != 0 { 1647 errorMessage = message 1648 } 1649 1650 switch { 1651 case strings.EqualFold("InternalServerException", errorCode): 1652 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1653 1654 case strings.EqualFold("ResourceNotFoundException", errorCode): 1655 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1656 1657 case strings.EqualFold("ValidationException", errorCode): 1658 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1659 1660 default: 1661 genericError := &smithy.GenericAPIError{ 1662 Code: errorCode, 1663 Message: errorMessage, 1664 } 1665 return genericError 1666 1667 } 1668} 1669 1670type awsRestjson1_deserializeOpTagResource struct { 1671} 1672 1673func (*awsRestjson1_deserializeOpTagResource) ID() string { 1674 return "OperationDeserializer" 1675} 1676 1677func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1678 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1679) { 1680 out, metadata, err = next.HandleDeserialize(ctx, in) 1681 if err != nil { 1682 return out, metadata, err 1683 } 1684 1685 response, ok := out.RawResponse.(*smithyhttp.Response) 1686 if !ok { 1687 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1688 } 1689 1690 if response.StatusCode < 200 || response.StatusCode >= 300 { 1691 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 1692 } 1693 output := &TagResourceOutput{} 1694 out.Result = output 1695 1696 return out, metadata, err 1697} 1698 1699func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1700 var errorBuffer bytes.Buffer 1701 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1702 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1703 } 1704 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1705 1706 errorCode := "UnknownError" 1707 errorMessage := errorCode 1708 1709 code := response.Header.Get("X-Amzn-ErrorType") 1710 if len(code) != 0 { 1711 errorCode = restjson.SanitizeErrorCode(code) 1712 } 1713 1714 var buff [1024]byte 1715 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1716 1717 body := io.TeeReader(errorBody, ringBuffer) 1718 decoder := json.NewDecoder(body) 1719 decoder.UseNumber() 1720 code, message, err := restjson.GetErrorInfo(decoder) 1721 if err != nil { 1722 var snapshot bytes.Buffer 1723 io.Copy(&snapshot, ringBuffer) 1724 err = &smithy.DeserializationError{ 1725 Err: fmt.Errorf("failed to decode response body, %w", err), 1726 Snapshot: snapshot.Bytes(), 1727 } 1728 return err 1729 } 1730 1731 errorBody.Seek(0, io.SeekStart) 1732 if len(code) != 0 { 1733 errorCode = restjson.SanitizeErrorCode(code) 1734 } 1735 if len(message) != 0 { 1736 errorMessage = message 1737 } 1738 1739 switch { 1740 case strings.EqualFold("InternalServerException", errorCode): 1741 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1742 1743 case strings.EqualFold("ResourceNotFoundException", errorCode): 1744 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1745 1746 case strings.EqualFold("ValidationException", errorCode): 1747 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1748 1749 default: 1750 genericError := &smithy.GenericAPIError{ 1751 Code: errorCode, 1752 Message: errorMessage, 1753 } 1754 return genericError 1755 1756 } 1757} 1758 1759type awsRestjson1_deserializeOpUntagResource struct { 1760} 1761 1762func (*awsRestjson1_deserializeOpUntagResource) ID() string { 1763 return "OperationDeserializer" 1764} 1765 1766func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1767 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1768) { 1769 out, metadata, err = next.HandleDeserialize(ctx, in) 1770 if err != nil { 1771 return out, metadata, err 1772 } 1773 1774 response, ok := out.RawResponse.(*smithyhttp.Response) 1775 if !ok { 1776 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1777 } 1778 1779 if response.StatusCode < 200 || response.StatusCode >= 300 { 1780 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 1781 } 1782 output := &UntagResourceOutput{} 1783 out.Result = output 1784 1785 return out, metadata, err 1786} 1787 1788func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1789 var errorBuffer bytes.Buffer 1790 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1791 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1792 } 1793 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1794 1795 errorCode := "UnknownError" 1796 errorMessage := errorCode 1797 1798 code := response.Header.Get("X-Amzn-ErrorType") 1799 if len(code) != 0 { 1800 errorCode = restjson.SanitizeErrorCode(code) 1801 } 1802 1803 var buff [1024]byte 1804 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1805 1806 body := io.TeeReader(errorBody, ringBuffer) 1807 decoder := json.NewDecoder(body) 1808 decoder.UseNumber() 1809 code, message, err := restjson.GetErrorInfo(decoder) 1810 if err != nil { 1811 var snapshot bytes.Buffer 1812 io.Copy(&snapshot, ringBuffer) 1813 err = &smithy.DeserializationError{ 1814 Err: fmt.Errorf("failed to decode response body, %w", err), 1815 Snapshot: snapshot.Bytes(), 1816 } 1817 return err 1818 } 1819 1820 errorBody.Seek(0, io.SeekStart) 1821 if len(code) != 0 { 1822 errorCode = restjson.SanitizeErrorCode(code) 1823 } 1824 if len(message) != 0 { 1825 errorMessage = message 1826 } 1827 1828 switch { 1829 case strings.EqualFold("InternalServerException", errorCode): 1830 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1831 1832 case strings.EqualFold("ResourceNotFoundException", errorCode): 1833 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1834 1835 case strings.EqualFold("ValidationException", errorCode): 1836 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1837 1838 default: 1839 genericError := &smithy.GenericAPIError{ 1840 Code: errorCode, 1841 Message: errorMessage, 1842 } 1843 return genericError 1844 1845 } 1846} 1847 1848type awsRestjson1_deserializeOpUpdateSuiteDefinition struct { 1849} 1850 1851func (*awsRestjson1_deserializeOpUpdateSuiteDefinition) ID() string { 1852 return "OperationDeserializer" 1853} 1854 1855func (m *awsRestjson1_deserializeOpUpdateSuiteDefinition) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1856 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1857) { 1858 out, metadata, err = next.HandleDeserialize(ctx, in) 1859 if err != nil { 1860 return out, metadata, err 1861 } 1862 1863 response, ok := out.RawResponse.(*smithyhttp.Response) 1864 if !ok { 1865 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1866 } 1867 1868 if response.StatusCode < 200 || response.StatusCode >= 300 { 1869 return out, metadata, awsRestjson1_deserializeOpErrorUpdateSuiteDefinition(response, &metadata) 1870 } 1871 output := &UpdateSuiteDefinitionOutput{} 1872 out.Result = output 1873 1874 var buff [1024]byte 1875 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1876 1877 body := io.TeeReader(response.Body, ringBuffer) 1878 1879 decoder := json.NewDecoder(body) 1880 decoder.UseNumber() 1881 var shape interface{} 1882 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 1890 } 1891 1892 err = awsRestjson1_deserializeOpDocumentUpdateSuiteDefinitionOutput(&output, shape) 1893 if err != nil { 1894 var snapshot bytes.Buffer 1895 io.Copy(&snapshot, ringBuffer) 1896 return out, metadata, &smithy.DeserializationError{ 1897 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1898 Snapshot: snapshot.Bytes(), 1899 } 1900 } 1901 1902 return out, metadata, err 1903} 1904 1905func awsRestjson1_deserializeOpErrorUpdateSuiteDefinition(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1906 var errorBuffer bytes.Buffer 1907 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1908 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1909 } 1910 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1911 1912 errorCode := "UnknownError" 1913 errorMessage := errorCode 1914 1915 code := response.Header.Get("X-Amzn-ErrorType") 1916 if len(code) != 0 { 1917 errorCode = restjson.SanitizeErrorCode(code) 1918 } 1919 1920 var buff [1024]byte 1921 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1922 1923 body := io.TeeReader(errorBody, ringBuffer) 1924 decoder := json.NewDecoder(body) 1925 decoder.UseNumber() 1926 code, message, err := restjson.GetErrorInfo(decoder) 1927 if err != nil { 1928 var snapshot bytes.Buffer 1929 io.Copy(&snapshot, ringBuffer) 1930 err = &smithy.DeserializationError{ 1931 Err: fmt.Errorf("failed to decode response body, %w", err), 1932 Snapshot: snapshot.Bytes(), 1933 } 1934 return err 1935 } 1936 1937 errorBody.Seek(0, io.SeekStart) 1938 if len(code) != 0 { 1939 errorCode = restjson.SanitizeErrorCode(code) 1940 } 1941 if len(message) != 0 { 1942 errorMessage = message 1943 } 1944 1945 switch { 1946 case strings.EqualFold("InternalServerException", errorCode): 1947 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody) 1948 1949 case strings.EqualFold("ValidationException", errorCode): 1950 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1951 1952 default: 1953 genericError := &smithy.GenericAPIError{ 1954 Code: errorCode, 1955 Message: errorMessage, 1956 } 1957 return genericError 1958 1959 } 1960} 1961 1962func awsRestjson1_deserializeOpDocumentUpdateSuiteDefinitionOutput(v **UpdateSuiteDefinitionOutput, value interface{}) error { 1963 if v == nil { 1964 return fmt.Errorf("unexpected nil of type %T", v) 1965 } 1966 if value == nil { 1967 return nil 1968 } 1969 1970 shape, ok := value.(map[string]interface{}) 1971 if !ok { 1972 return fmt.Errorf("unexpected JSON type %v", value) 1973 } 1974 1975 var sv *UpdateSuiteDefinitionOutput 1976 if *v == nil { 1977 sv = &UpdateSuiteDefinitionOutput{} 1978 } else { 1979 sv = *v 1980 } 1981 1982 for key, value := range shape { 1983 switch key { 1984 case "createdAt": 1985 if value != nil { 1986 switch jtv := value.(type) { 1987 case json.Number: 1988 f64, err := jtv.Float64() 1989 if err != nil { 1990 return err 1991 } 1992 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1993 1994 default: 1995 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 1996 1997 } 1998 } 1999 2000 case "lastUpdatedAt": 2001 if value != nil { 2002 switch jtv := value.(type) { 2003 case json.Number: 2004 f64, err := jtv.Float64() 2005 if err != nil { 2006 return err 2007 } 2008 sv.LastUpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2009 2010 default: 2011 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 2012 2013 } 2014 } 2015 2016 case "suiteDefinitionArn": 2017 if value != nil { 2018 jtv, ok := value.(string) 2019 if !ok { 2020 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 2021 } 2022 sv.SuiteDefinitionArn = ptr.String(jtv) 2023 } 2024 2025 case "suiteDefinitionId": 2026 if value != nil { 2027 jtv, ok := value.(string) 2028 if !ok { 2029 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2030 } 2031 sv.SuiteDefinitionId = ptr.String(jtv) 2032 } 2033 2034 case "suiteDefinitionName": 2035 if value != nil { 2036 jtv, ok := value.(string) 2037 if !ok { 2038 return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value) 2039 } 2040 sv.SuiteDefinitionName = ptr.String(jtv) 2041 } 2042 2043 case "suiteDefinitionVersion": 2044 if value != nil { 2045 jtv, ok := value.(string) 2046 if !ok { 2047 return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value) 2048 } 2049 sv.SuiteDefinitionVersion = ptr.String(jtv) 2050 } 2051 2052 default: 2053 _, _ = key, value 2054 2055 } 2056 } 2057 *v = sv 2058 return nil 2059} 2060 2061func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2062 output := &types.ConflictException{} 2063 var buff [1024]byte 2064 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2065 2066 body := io.TeeReader(errorBody, ringBuffer) 2067 decoder := json.NewDecoder(body) 2068 decoder.UseNumber() 2069 var shape interface{} 2070 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2071 var snapshot bytes.Buffer 2072 io.Copy(&snapshot, ringBuffer) 2073 err = &smithy.DeserializationError{ 2074 Err: fmt.Errorf("failed to decode response body, %w", err), 2075 Snapshot: snapshot.Bytes(), 2076 } 2077 return err 2078 } 2079 2080 err := awsRestjson1_deserializeDocumentConflictException(&output, shape) 2081 2082 if err != nil { 2083 var snapshot bytes.Buffer 2084 io.Copy(&snapshot, ringBuffer) 2085 err = &smithy.DeserializationError{ 2086 Err: fmt.Errorf("failed to decode response body, %w", err), 2087 Snapshot: snapshot.Bytes(), 2088 } 2089 return err 2090 } 2091 2092 errorBody.Seek(0, io.SeekStart) 2093 2094 return output 2095} 2096 2097func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2098 output := &types.InternalServerException{} 2099 var buff [1024]byte 2100 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2101 2102 body := io.TeeReader(errorBody, ringBuffer) 2103 decoder := json.NewDecoder(body) 2104 decoder.UseNumber() 2105 var shape interface{} 2106 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2107 var snapshot bytes.Buffer 2108 io.Copy(&snapshot, ringBuffer) 2109 err = &smithy.DeserializationError{ 2110 Err: fmt.Errorf("failed to decode response body, %w", err), 2111 Snapshot: snapshot.Bytes(), 2112 } 2113 return err 2114 } 2115 2116 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape) 2117 2118 if err != nil { 2119 var snapshot bytes.Buffer 2120 io.Copy(&snapshot, ringBuffer) 2121 err = &smithy.DeserializationError{ 2122 Err: fmt.Errorf("failed to decode response body, %w", err), 2123 Snapshot: snapshot.Bytes(), 2124 } 2125 return err 2126 } 2127 2128 errorBody.Seek(0, io.SeekStart) 2129 2130 return output 2131} 2132 2133func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2134 output := &types.ResourceNotFoundException{} 2135 var buff [1024]byte 2136 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2137 2138 body := io.TeeReader(errorBody, ringBuffer) 2139 decoder := json.NewDecoder(body) 2140 decoder.UseNumber() 2141 var shape interface{} 2142 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2143 var snapshot bytes.Buffer 2144 io.Copy(&snapshot, ringBuffer) 2145 err = &smithy.DeserializationError{ 2146 Err: fmt.Errorf("failed to decode response body, %w", err), 2147 Snapshot: snapshot.Bytes(), 2148 } 2149 return err 2150 } 2151 2152 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 2153 2154 if err != nil { 2155 var snapshot bytes.Buffer 2156 io.Copy(&snapshot, ringBuffer) 2157 err = &smithy.DeserializationError{ 2158 Err: fmt.Errorf("failed to decode response body, %w", err), 2159 Snapshot: snapshot.Bytes(), 2160 } 2161 return err 2162 } 2163 2164 errorBody.Seek(0, io.SeekStart) 2165 2166 return output 2167} 2168 2169func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2170 output := &types.ValidationException{} 2171 var buff [1024]byte 2172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2173 2174 body := io.TeeReader(errorBody, ringBuffer) 2175 decoder := json.NewDecoder(body) 2176 decoder.UseNumber() 2177 var shape interface{} 2178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2179 var snapshot bytes.Buffer 2180 io.Copy(&snapshot, ringBuffer) 2181 err = &smithy.DeserializationError{ 2182 Err: fmt.Errorf("failed to decode response body, %w", err), 2183 Snapshot: snapshot.Bytes(), 2184 } 2185 return err 2186 } 2187 2188 err := awsRestjson1_deserializeDocumentValidationException(&output, shape) 2189 2190 if err != nil { 2191 var snapshot bytes.Buffer 2192 io.Copy(&snapshot, ringBuffer) 2193 err = &smithy.DeserializationError{ 2194 Err: fmt.Errorf("failed to decode response body, %w", err), 2195 Snapshot: snapshot.Bytes(), 2196 } 2197 return err 2198 } 2199 2200 errorBody.Seek(0, io.SeekStart) 2201 2202 return output 2203} 2204 2205func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 2206 if v == nil { 2207 return fmt.Errorf("unexpected nil of type %T", v) 2208 } 2209 if value == nil { 2210 return nil 2211 } 2212 2213 shape, ok := value.(map[string]interface{}) 2214 if !ok { 2215 return fmt.Errorf("unexpected JSON type %v", value) 2216 } 2217 2218 var sv *types.ConflictException 2219 if *v == nil { 2220 sv = &types.ConflictException{} 2221 } else { 2222 sv = *v 2223 } 2224 2225 for key, value := range shape { 2226 switch key { 2227 case "message": 2228 if value != nil { 2229 jtv, ok := value.(string) 2230 if !ok { 2231 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 2232 } 2233 sv.Message = ptr.String(jtv) 2234 } 2235 2236 default: 2237 _, _ = key, value 2238 2239 } 2240 } 2241 *v = sv 2242 return nil 2243} 2244 2245func awsRestjson1_deserializeDocumentDeviceUnderTest(v **types.DeviceUnderTest, value interface{}) error { 2246 if v == nil { 2247 return fmt.Errorf("unexpected nil of type %T", v) 2248 } 2249 if value == nil { 2250 return nil 2251 } 2252 2253 shape, ok := value.(map[string]interface{}) 2254 if !ok { 2255 return fmt.Errorf("unexpected JSON type %v", value) 2256 } 2257 2258 var sv *types.DeviceUnderTest 2259 if *v == nil { 2260 sv = &types.DeviceUnderTest{} 2261 } else { 2262 sv = *v 2263 } 2264 2265 for key, value := range shape { 2266 switch key { 2267 case "certificateArn": 2268 if value != nil { 2269 jtv, ok := value.(string) 2270 if !ok { 2271 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 2272 } 2273 sv.CertificateArn = ptr.String(jtv) 2274 } 2275 2276 case "thingArn": 2277 if value != nil { 2278 jtv, ok := value.(string) 2279 if !ok { 2280 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 2281 } 2282 sv.ThingArn = ptr.String(jtv) 2283 } 2284 2285 default: 2286 _, _ = key, value 2287 2288 } 2289 } 2290 *v = sv 2291 return nil 2292} 2293 2294func awsRestjson1_deserializeDocumentDeviceUnderTestList(v *[]types.DeviceUnderTest, value interface{}) error { 2295 if v == nil { 2296 return fmt.Errorf("unexpected nil of type %T", v) 2297 } 2298 if value == nil { 2299 return nil 2300 } 2301 2302 shape, ok := value.([]interface{}) 2303 if !ok { 2304 return fmt.Errorf("unexpected JSON type %v", value) 2305 } 2306 2307 var cv []types.DeviceUnderTest 2308 if *v == nil { 2309 cv = []types.DeviceUnderTest{} 2310 } else { 2311 cv = *v 2312 } 2313 2314 for _, value := range shape { 2315 var col types.DeviceUnderTest 2316 destAddr := &col 2317 if err := awsRestjson1_deserializeDocumentDeviceUnderTest(&destAddr, value); err != nil { 2318 return err 2319 } 2320 col = *destAddr 2321 cv = append(cv, col) 2322 2323 } 2324 *v = cv 2325 return nil 2326} 2327 2328func awsRestjson1_deserializeDocumentGroupResult(v **types.GroupResult, value interface{}) error { 2329 if v == nil { 2330 return fmt.Errorf("unexpected nil of type %T", v) 2331 } 2332 if value == nil { 2333 return nil 2334 } 2335 2336 shape, ok := value.(map[string]interface{}) 2337 if !ok { 2338 return fmt.Errorf("unexpected JSON type %v", value) 2339 } 2340 2341 var sv *types.GroupResult 2342 if *v == nil { 2343 sv = &types.GroupResult{} 2344 } else { 2345 sv = *v 2346 } 2347 2348 for key, value := range shape { 2349 switch key { 2350 case "groupId": 2351 if value != nil { 2352 jtv, ok := value.(string) 2353 if !ok { 2354 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2355 } 2356 sv.GroupId = ptr.String(jtv) 2357 } 2358 2359 case "groupName": 2360 if value != nil { 2361 jtv, ok := value.(string) 2362 if !ok { 2363 return fmt.Errorf("expected GroupName to be of type string, got %T instead", value) 2364 } 2365 sv.GroupName = ptr.String(jtv) 2366 } 2367 2368 case "tests": 2369 if err := awsRestjson1_deserializeDocumentTestCaseRuns(&sv.Tests, value); err != nil { 2370 return err 2371 } 2372 2373 default: 2374 _, _ = key, value 2375 2376 } 2377 } 2378 *v = sv 2379 return nil 2380} 2381 2382func awsRestjson1_deserializeDocumentGroupResultList(v *[]types.GroupResult, value interface{}) error { 2383 if v == nil { 2384 return fmt.Errorf("unexpected nil of type %T", v) 2385 } 2386 if value == nil { 2387 return nil 2388 } 2389 2390 shape, ok := value.([]interface{}) 2391 if !ok { 2392 return fmt.Errorf("unexpected JSON type %v", value) 2393 } 2394 2395 var cv []types.GroupResult 2396 if *v == nil { 2397 cv = []types.GroupResult{} 2398 } else { 2399 cv = *v 2400 } 2401 2402 for _, value := range shape { 2403 var col types.GroupResult 2404 destAddr := &col 2405 if err := awsRestjson1_deserializeDocumentGroupResult(&destAddr, value); err != nil { 2406 return err 2407 } 2408 col = *destAddr 2409 cv = append(cv, col) 2410 2411 } 2412 *v = cv 2413 return nil 2414} 2415 2416func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 2417 if v == nil { 2418 return fmt.Errorf("unexpected nil of type %T", v) 2419 } 2420 if value == nil { 2421 return nil 2422 } 2423 2424 shape, ok := value.(map[string]interface{}) 2425 if !ok { 2426 return fmt.Errorf("unexpected JSON type %v", value) 2427 } 2428 2429 var sv *types.InternalServerException 2430 if *v == nil { 2431 sv = &types.InternalServerException{} 2432 } else { 2433 sv = *v 2434 } 2435 2436 for key, value := range shape { 2437 switch key { 2438 case "message": 2439 if value != nil { 2440 jtv, ok := value.(string) 2441 if !ok { 2442 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 2443 } 2444 sv.Message = ptr.String(jtv) 2445 } 2446 2447 default: 2448 _, _ = key, value 2449 2450 } 2451 } 2452 *v = sv 2453 return nil 2454} 2455 2456func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 2457 if v == nil { 2458 return fmt.Errorf("unexpected nil of type %T", v) 2459 } 2460 if value == nil { 2461 return nil 2462 } 2463 2464 shape, ok := value.(map[string]interface{}) 2465 if !ok { 2466 return fmt.Errorf("unexpected JSON type %v", value) 2467 } 2468 2469 var sv *types.ResourceNotFoundException 2470 if *v == nil { 2471 sv = &types.ResourceNotFoundException{} 2472 } else { 2473 sv = *v 2474 } 2475 2476 for key, value := range shape { 2477 switch key { 2478 case "message": 2479 if value != nil { 2480 jtv, ok := value.(string) 2481 if !ok { 2482 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 2483 } 2484 sv.Message = ptr.String(jtv) 2485 } 2486 2487 default: 2488 _, _ = key, value 2489 2490 } 2491 } 2492 *v = sv 2493 return nil 2494} 2495 2496func awsRestjson1_deserializeDocumentSelectedTestList(v *[]string, value interface{}) error { 2497 if v == nil { 2498 return fmt.Errorf("unexpected nil of type %T", v) 2499 } 2500 if value == nil { 2501 return nil 2502 } 2503 2504 shape, ok := value.([]interface{}) 2505 if !ok { 2506 return fmt.Errorf("unexpected JSON type %v", value) 2507 } 2508 2509 var cv []string 2510 if *v == nil { 2511 cv = []string{} 2512 } else { 2513 cv = *v 2514 } 2515 2516 for _, value := range shape { 2517 var col string 2518 if value != nil { 2519 jtv, ok := value.(string) 2520 if !ok { 2521 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2522 } 2523 col = jtv 2524 } 2525 cv = append(cv, col) 2526 2527 } 2528 *v = cv 2529 return nil 2530} 2531 2532func awsRestjson1_deserializeDocumentSuiteDefinitionConfiguration(v **types.SuiteDefinitionConfiguration, value interface{}) error { 2533 if v == nil { 2534 return fmt.Errorf("unexpected nil of type %T", v) 2535 } 2536 if value == nil { 2537 return nil 2538 } 2539 2540 shape, ok := value.(map[string]interface{}) 2541 if !ok { 2542 return fmt.Errorf("unexpected JSON type %v", value) 2543 } 2544 2545 var sv *types.SuiteDefinitionConfiguration 2546 if *v == nil { 2547 sv = &types.SuiteDefinitionConfiguration{} 2548 } else { 2549 sv = *v 2550 } 2551 2552 for key, value := range shape { 2553 switch key { 2554 case "devicePermissionRoleArn": 2555 if value != nil { 2556 jtv, ok := value.(string) 2557 if !ok { 2558 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 2559 } 2560 sv.DevicePermissionRoleArn = ptr.String(jtv) 2561 } 2562 2563 case "devices": 2564 if err := awsRestjson1_deserializeDocumentDeviceUnderTestList(&sv.Devices, value); err != nil { 2565 return err 2566 } 2567 2568 case "intendedForQualification": 2569 if value != nil { 2570 jtv, ok := value.(bool) 2571 if !ok { 2572 return fmt.Errorf("expected IntendedForQualificationBoolean to be of type *bool, got %T instead", value) 2573 } 2574 sv.IntendedForQualification = jtv 2575 } 2576 2577 case "rootGroup": 2578 if value != nil { 2579 jtv, ok := value.(string) 2580 if !ok { 2581 return fmt.Errorf("expected RootGroup to be of type string, got %T instead", value) 2582 } 2583 sv.RootGroup = ptr.String(jtv) 2584 } 2585 2586 case "suiteDefinitionName": 2587 if value != nil { 2588 jtv, ok := value.(string) 2589 if !ok { 2590 return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value) 2591 } 2592 sv.SuiteDefinitionName = ptr.String(jtv) 2593 } 2594 2595 default: 2596 _, _ = key, value 2597 2598 } 2599 } 2600 *v = sv 2601 return nil 2602} 2603 2604func awsRestjson1_deserializeDocumentSuiteDefinitionInformation(v **types.SuiteDefinitionInformation, value interface{}) error { 2605 if v == nil { 2606 return fmt.Errorf("unexpected nil of type %T", v) 2607 } 2608 if value == nil { 2609 return nil 2610 } 2611 2612 shape, ok := value.(map[string]interface{}) 2613 if !ok { 2614 return fmt.Errorf("unexpected JSON type %v", value) 2615 } 2616 2617 var sv *types.SuiteDefinitionInformation 2618 if *v == nil { 2619 sv = &types.SuiteDefinitionInformation{} 2620 } else { 2621 sv = *v 2622 } 2623 2624 for key, value := range shape { 2625 switch key { 2626 case "createdAt": 2627 if value != nil { 2628 switch jtv := value.(type) { 2629 case json.Number: 2630 f64, err := jtv.Float64() 2631 if err != nil { 2632 return err 2633 } 2634 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2635 2636 default: 2637 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 2638 2639 } 2640 } 2641 2642 case "defaultDevices": 2643 if err := awsRestjson1_deserializeDocumentDeviceUnderTestList(&sv.DefaultDevices, value); err != nil { 2644 return err 2645 } 2646 2647 case "intendedForQualification": 2648 if value != nil { 2649 jtv, ok := value.(bool) 2650 if !ok { 2651 return fmt.Errorf("expected IntendedForQualificationBoolean to be of type *bool, got %T instead", value) 2652 } 2653 sv.IntendedForQualification = jtv 2654 } 2655 2656 case "suiteDefinitionId": 2657 if value != nil { 2658 jtv, ok := value.(string) 2659 if !ok { 2660 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2661 } 2662 sv.SuiteDefinitionId = ptr.String(jtv) 2663 } 2664 2665 case "suiteDefinitionName": 2666 if value != nil { 2667 jtv, ok := value.(string) 2668 if !ok { 2669 return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value) 2670 } 2671 sv.SuiteDefinitionName = ptr.String(jtv) 2672 } 2673 2674 default: 2675 _, _ = key, value 2676 2677 } 2678 } 2679 *v = sv 2680 return nil 2681} 2682 2683func awsRestjson1_deserializeDocumentSuiteDefinitionInformationList(v *[]types.SuiteDefinitionInformation, value interface{}) error { 2684 if v == nil { 2685 return fmt.Errorf("unexpected nil of type %T", v) 2686 } 2687 if value == nil { 2688 return nil 2689 } 2690 2691 shape, ok := value.([]interface{}) 2692 if !ok { 2693 return fmt.Errorf("unexpected JSON type %v", value) 2694 } 2695 2696 var cv []types.SuiteDefinitionInformation 2697 if *v == nil { 2698 cv = []types.SuiteDefinitionInformation{} 2699 } else { 2700 cv = *v 2701 } 2702 2703 for _, value := range shape { 2704 var col types.SuiteDefinitionInformation 2705 destAddr := &col 2706 if err := awsRestjson1_deserializeDocumentSuiteDefinitionInformation(&destAddr, value); err != nil { 2707 return err 2708 } 2709 col = *destAddr 2710 cv = append(cv, col) 2711 2712 } 2713 *v = cv 2714 return nil 2715} 2716 2717func awsRestjson1_deserializeDocumentSuiteRunConfiguration(v **types.SuiteRunConfiguration, value interface{}) error { 2718 if v == nil { 2719 return fmt.Errorf("unexpected nil of type %T", v) 2720 } 2721 if value == nil { 2722 return nil 2723 } 2724 2725 shape, ok := value.(map[string]interface{}) 2726 if !ok { 2727 return fmt.Errorf("unexpected JSON type %v", value) 2728 } 2729 2730 var sv *types.SuiteRunConfiguration 2731 if *v == nil { 2732 sv = &types.SuiteRunConfiguration{} 2733 } else { 2734 sv = *v 2735 } 2736 2737 for key, value := range shape { 2738 switch key { 2739 case "primaryDevice": 2740 if err := awsRestjson1_deserializeDocumentDeviceUnderTest(&sv.PrimaryDevice, value); err != nil { 2741 return err 2742 } 2743 2744 case "selectedTestList": 2745 if err := awsRestjson1_deserializeDocumentSelectedTestList(&sv.SelectedTestList, value); err != nil { 2746 return err 2747 } 2748 2749 default: 2750 _, _ = key, value 2751 2752 } 2753 } 2754 *v = sv 2755 return nil 2756} 2757 2758func awsRestjson1_deserializeDocumentSuiteRunInformation(v **types.SuiteRunInformation, value interface{}) error { 2759 if v == nil { 2760 return fmt.Errorf("unexpected nil of type %T", v) 2761 } 2762 if value == nil { 2763 return nil 2764 } 2765 2766 shape, ok := value.(map[string]interface{}) 2767 if !ok { 2768 return fmt.Errorf("unexpected JSON type %v", value) 2769 } 2770 2771 var sv *types.SuiteRunInformation 2772 if *v == nil { 2773 sv = &types.SuiteRunInformation{} 2774 } else { 2775 sv = *v 2776 } 2777 2778 for key, value := range shape { 2779 switch key { 2780 case "createdAt": 2781 if value != nil { 2782 switch jtv := value.(type) { 2783 case json.Number: 2784 f64, err := jtv.Float64() 2785 if err != nil { 2786 return err 2787 } 2788 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2789 2790 default: 2791 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 2792 2793 } 2794 } 2795 2796 case "endAt": 2797 if value != nil { 2798 switch jtv := value.(type) { 2799 case json.Number: 2800 f64, err := jtv.Float64() 2801 if err != nil { 2802 return err 2803 } 2804 sv.EndAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2805 2806 default: 2807 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 2808 2809 } 2810 } 2811 2812 case "failed": 2813 if value != nil { 2814 jtv, ok := value.(json.Number) 2815 if !ok { 2816 return fmt.Errorf("expected SuiteRunResultCount to be json.Number, got %T instead", value) 2817 } 2818 i64, err := jtv.Int64() 2819 if err != nil { 2820 return err 2821 } 2822 sv.Failed = int32(i64) 2823 } 2824 2825 case "passed": 2826 if value != nil { 2827 jtv, ok := value.(json.Number) 2828 if !ok { 2829 return fmt.Errorf("expected SuiteRunResultCount to be json.Number, got %T instead", value) 2830 } 2831 i64, err := jtv.Int64() 2832 if err != nil { 2833 return err 2834 } 2835 sv.Passed = int32(i64) 2836 } 2837 2838 case "startedAt": 2839 if value != nil { 2840 switch jtv := value.(type) { 2841 case json.Number: 2842 f64, err := jtv.Float64() 2843 if err != nil { 2844 return err 2845 } 2846 sv.StartedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2847 2848 default: 2849 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 2850 2851 } 2852 } 2853 2854 case "status": 2855 if value != nil { 2856 jtv, ok := value.(string) 2857 if !ok { 2858 return fmt.Errorf("expected SuiteRunStatus to be of type string, got %T instead", value) 2859 } 2860 sv.Status = types.SuiteRunStatus(jtv) 2861 } 2862 2863 case "suiteDefinitionId": 2864 if value != nil { 2865 jtv, ok := value.(string) 2866 if !ok { 2867 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2868 } 2869 sv.SuiteDefinitionId = ptr.String(jtv) 2870 } 2871 2872 case "suiteDefinitionName": 2873 if value != nil { 2874 jtv, ok := value.(string) 2875 if !ok { 2876 return fmt.Errorf("expected SuiteDefinitionName to be of type string, got %T instead", value) 2877 } 2878 sv.SuiteDefinitionName = ptr.String(jtv) 2879 } 2880 2881 case "suiteDefinitionVersion": 2882 if value != nil { 2883 jtv, ok := value.(string) 2884 if !ok { 2885 return fmt.Errorf("expected SuiteDefinitionVersion to be of type string, got %T instead", value) 2886 } 2887 sv.SuiteDefinitionVersion = ptr.String(jtv) 2888 } 2889 2890 case "suiteRunId": 2891 if value != nil { 2892 jtv, ok := value.(string) 2893 if !ok { 2894 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 2895 } 2896 sv.SuiteRunId = ptr.String(jtv) 2897 } 2898 2899 default: 2900 _, _ = key, value 2901 2902 } 2903 } 2904 *v = sv 2905 return nil 2906} 2907 2908func awsRestjson1_deserializeDocumentSuiteRunsList(v *[]types.SuiteRunInformation, value interface{}) error { 2909 if v == nil { 2910 return fmt.Errorf("unexpected nil of type %T", v) 2911 } 2912 if value == nil { 2913 return nil 2914 } 2915 2916 shape, ok := value.([]interface{}) 2917 if !ok { 2918 return fmt.Errorf("unexpected JSON type %v", value) 2919 } 2920 2921 var cv []types.SuiteRunInformation 2922 if *v == nil { 2923 cv = []types.SuiteRunInformation{} 2924 } else { 2925 cv = *v 2926 } 2927 2928 for _, value := range shape { 2929 var col types.SuiteRunInformation 2930 destAddr := &col 2931 if err := awsRestjson1_deserializeDocumentSuiteRunInformation(&destAddr, value); err != nil { 2932 return err 2933 } 2934 col = *destAddr 2935 cv = append(cv, col) 2936 2937 } 2938 *v = cv 2939 return nil 2940} 2941 2942func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 2943 if v == nil { 2944 return fmt.Errorf("unexpected nil of type %T", v) 2945 } 2946 if value == nil { 2947 return nil 2948 } 2949 2950 shape, ok := value.(map[string]interface{}) 2951 if !ok { 2952 return fmt.Errorf("unexpected JSON type %v", value) 2953 } 2954 2955 var mv map[string]string 2956 if *v == nil { 2957 mv = map[string]string{} 2958 } else { 2959 mv = *v 2960 } 2961 2962 for key, value := range shape { 2963 var parsedVal string 2964 if value != nil { 2965 jtv, ok := value.(string) 2966 if !ok { 2967 return fmt.Errorf("expected String256 to be of type string, got %T instead", value) 2968 } 2969 parsedVal = jtv 2970 } 2971 mv[key] = parsedVal 2972 2973 } 2974 *v = mv 2975 return nil 2976} 2977 2978func awsRestjson1_deserializeDocumentTestCaseRun(v **types.TestCaseRun, value interface{}) error { 2979 if v == nil { 2980 return fmt.Errorf("unexpected nil of type %T", v) 2981 } 2982 if value == nil { 2983 return nil 2984 } 2985 2986 shape, ok := value.(map[string]interface{}) 2987 if !ok { 2988 return fmt.Errorf("unexpected JSON type %v", value) 2989 } 2990 2991 var sv *types.TestCaseRun 2992 if *v == nil { 2993 sv = &types.TestCaseRun{} 2994 } else { 2995 sv = *v 2996 } 2997 2998 for key, value := range shape { 2999 switch key { 3000 case "endTime": 3001 if value != nil { 3002 switch jtv := value.(type) { 3003 case json.Number: 3004 f64, err := jtv.Float64() 3005 if err != nil { 3006 return err 3007 } 3008 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3009 3010 default: 3011 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 3012 3013 } 3014 } 3015 3016 case "failure": 3017 if value != nil { 3018 jtv, ok := value.(string) 3019 if !ok { 3020 return fmt.Errorf("expected Failure to be of type string, got %T instead", value) 3021 } 3022 sv.Failure = ptr.String(jtv) 3023 } 3024 3025 case "logUrl": 3026 if value != nil { 3027 jtv, ok := value.(string) 3028 if !ok { 3029 return fmt.Errorf("expected LogUrl to be of type string, got %T instead", value) 3030 } 3031 sv.LogUrl = ptr.String(jtv) 3032 } 3033 3034 case "startTime": 3035 if value != nil { 3036 switch jtv := value.(type) { 3037 case json.Number: 3038 f64, err := jtv.Float64() 3039 if err != nil { 3040 return err 3041 } 3042 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3043 3044 default: 3045 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 3046 3047 } 3048 } 3049 3050 case "status": 3051 if value != nil { 3052 jtv, ok := value.(string) 3053 if !ok { 3054 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 3055 } 3056 sv.Status = types.Status(jtv) 3057 } 3058 3059 case "testCaseDefinitionId": 3060 if value != nil { 3061 jtv, ok := value.(string) 3062 if !ok { 3063 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 3064 } 3065 sv.TestCaseDefinitionId = ptr.String(jtv) 3066 } 3067 3068 case "testCaseDefinitionName": 3069 if value != nil { 3070 jtv, ok := value.(string) 3071 if !ok { 3072 return fmt.Errorf("expected TestCaseDefinitionName to be of type string, got %T instead", value) 3073 } 3074 sv.TestCaseDefinitionName = ptr.String(jtv) 3075 } 3076 3077 case "testCaseRunId": 3078 if value != nil { 3079 jtv, ok := value.(string) 3080 if !ok { 3081 return fmt.Errorf("expected UUID to be of type string, got %T instead", value) 3082 } 3083 sv.TestCaseRunId = ptr.String(jtv) 3084 } 3085 3086 case "warnings": 3087 if value != nil { 3088 jtv, ok := value.(string) 3089 if !ok { 3090 return fmt.Errorf("expected Warnings to be of type string, got %T instead", value) 3091 } 3092 sv.Warnings = ptr.String(jtv) 3093 } 3094 3095 default: 3096 _, _ = key, value 3097 3098 } 3099 } 3100 *v = sv 3101 return nil 3102} 3103 3104func awsRestjson1_deserializeDocumentTestCaseRuns(v *[]types.TestCaseRun, value interface{}) error { 3105 if v == nil { 3106 return fmt.Errorf("unexpected nil of type %T", v) 3107 } 3108 if value == nil { 3109 return nil 3110 } 3111 3112 shape, ok := value.([]interface{}) 3113 if !ok { 3114 return fmt.Errorf("unexpected JSON type %v", value) 3115 } 3116 3117 var cv []types.TestCaseRun 3118 if *v == nil { 3119 cv = []types.TestCaseRun{} 3120 } else { 3121 cv = *v 3122 } 3123 3124 for _, value := range shape { 3125 var col types.TestCaseRun 3126 destAddr := &col 3127 if err := awsRestjson1_deserializeDocumentTestCaseRun(&destAddr, value); err != nil { 3128 return err 3129 } 3130 col = *destAddr 3131 cv = append(cv, col) 3132 3133 } 3134 *v = cv 3135 return nil 3136} 3137 3138func awsRestjson1_deserializeDocumentTestResult(v **types.TestResult, value interface{}) error { 3139 if v == nil { 3140 return fmt.Errorf("unexpected nil of type %T", v) 3141 } 3142 if value == nil { 3143 return nil 3144 } 3145 3146 shape, ok := value.(map[string]interface{}) 3147 if !ok { 3148 return fmt.Errorf("unexpected JSON type %v", value) 3149 } 3150 3151 var sv *types.TestResult 3152 if *v == nil { 3153 sv = &types.TestResult{} 3154 } else { 3155 sv = *v 3156 } 3157 3158 for key, value := range shape { 3159 switch key { 3160 case "groups": 3161 if err := awsRestjson1_deserializeDocumentGroupResultList(&sv.Groups, value); err != nil { 3162 return err 3163 } 3164 3165 default: 3166 _, _ = key, value 3167 3168 } 3169 } 3170 *v = sv 3171 return nil 3172} 3173 3174func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 3175 if v == nil { 3176 return fmt.Errorf("unexpected nil of type %T", v) 3177 } 3178 if value == nil { 3179 return nil 3180 } 3181 3182 shape, ok := value.(map[string]interface{}) 3183 if !ok { 3184 return fmt.Errorf("unexpected JSON type %v", value) 3185 } 3186 3187 var sv *types.ValidationException 3188 if *v == nil { 3189 sv = &types.ValidationException{} 3190 } else { 3191 sv = *v 3192 } 3193 3194 for key, value := range shape { 3195 switch key { 3196 case "message": 3197 if value != nil { 3198 jtv, ok := value.(string) 3199 if !ok { 3200 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3201 } 3202 sv.Message = ptr.String(jtv) 3203 } 3204 3205 default: 3206 _, _ = key, value 3207 3208 } 3209 } 3210 *v = sv 3211 return nil 3212} 3213