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