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