1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package xray 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/xray/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsRestjson1_deserializeOpBatchGetTraces struct { 23} 24 25func (*awsRestjson1_deserializeOpBatchGetTraces) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpBatchGetTraces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorBatchGetTraces(response, &metadata) 44 } 45 output := &BatchGetTracesOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsRestjson1_deserializeOpDocumentBatchGetTracesOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 return out, metadata, &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 } 75 76 return out, metadata, err 77} 78 79func awsRestjson1_deserializeOpErrorBatchGetTraces(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("InvalidRequestException", errorCode): 121 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 122 123 case strings.EqualFold("ThrottledException", errorCode): 124 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 125 126 default: 127 genericError := &smithy.GenericAPIError{ 128 Code: errorCode, 129 Message: errorMessage, 130 } 131 return genericError 132 133 } 134} 135 136func awsRestjson1_deserializeOpDocumentBatchGetTracesOutput(v **BatchGetTracesOutput, value interface{}) error { 137 if v == nil { 138 return fmt.Errorf("unexpected nil of type %T", v) 139 } 140 if value == nil { 141 return nil 142 } 143 144 shape, ok := value.(map[string]interface{}) 145 if !ok { 146 return fmt.Errorf("unexpected JSON type %v", value) 147 } 148 149 var sv *BatchGetTracesOutput 150 if *v == nil { 151 sv = &BatchGetTracesOutput{} 152 } else { 153 sv = *v 154 } 155 156 for key, value := range shape { 157 switch key { 158 case "NextToken": 159 if value != nil { 160 jtv, ok := value.(string) 161 if !ok { 162 return fmt.Errorf("expected String to be of type string, got %T instead", value) 163 } 164 sv.NextToken = ptr.String(jtv) 165 } 166 167 case "Traces": 168 if err := awsRestjson1_deserializeDocumentTraceList(&sv.Traces, value); err != nil { 169 return err 170 } 171 172 case "UnprocessedTraceIds": 173 if err := awsRestjson1_deserializeDocumentUnprocessedTraceIdList(&sv.UnprocessedTraceIds, value); err != nil { 174 return err 175 } 176 177 default: 178 _, _ = key, value 179 180 } 181 } 182 *v = sv 183 return nil 184} 185 186type awsRestjson1_deserializeOpCreateGroup struct { 187} 188 189func (*awsRestjson1_deserializeOpCreateGroup) ID() string { 190 return "OperationDeserializer" 191} 192 193func (m *awsRestjson1_deserializeOpCreateGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 194 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 195) { 196 out, metadata, err = next.HandleDeserialize(ctx, in) 197 if err != nil { 198 return out, metadata, err 199 } 200 201 response, ok := out.RawResponse.(*smithyhttp.Response) 202 if !ok { 203 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 204 } 205 206 if response.StatusCode < 200 || response.StatusCode >= 300 { 207 return out, metadata, awsRestjson1_deserializeOpErrorCreateGroup(response, &metadata) 208 } 209 output := &CreateGroupOutput{} 210 out.Result = output 211 212 var buff [1024]byte 213 ringBuffer := smithyio.NewRingBuffer(buff[:]) 214 215 body := io.TeeReader(response.Body, ringBuffer) 216 217 decoder := json.NewDecoder(body) 218 decoder.UseNumber() 219 var shape interface{} 220 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 221 var snapshot bytes.Buffer 222 io.Copy(&snapshot, ringBuffer) 223 err = &smithy.DeserializationError{ 224 Err: fmt.Errorf("failed to decode response body, %w", err), 225 Snapshot: snapshot.Bytes(), 226 } 227 return out, metadata, err 228 } 229 230 err = awsRestjson1_deserializeOpDocumentCreateGroupOutput(&output, shape) 231 if err != nil { 232 var snapshot bytes.Buffer 233 io.Copy(&snapshot, ringBuffer) 234 return out, metadata, &smithy.DeserializationError{ 235 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 236 Snapshot: snapshot.Bytes(), 237 } 238 } 239 240 return out, metadata, err 241} 242 243func awsRestjson1_deserializeOpErrorCreateGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 244 var errorBuffer bytes.Buffer 245 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 246 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 247 } 248 errorBody := bytes.NewReader(errorBuffer.Bytes()) 249 250 errorCode := "UnknownError" 251 errorMessage := errorCode 252 253 code := response.Header.Get("X-Amzn-ErrorType") 254 if len(code) != 0 { 255 errorCode = restjson.SanitizeErrorCode(code) 256 } 257 258 var buff [1024]byte 259 ringBuffer := smithyio.NewRingBuffer(buff[:]) 260 261 body := io.TeeReader(errorBody, ringBuffer) 262 decoder := json.NewDecoder(body) 263 decoder.UseNumber() 264 code, message, err := restjson.GetErrorInfo(decoder) 265 if err != nil { 266 var snapshot bytes.Buffer 267 io.Copy(&snapshot, ringBuffer) 268 err = &smithy.DeserializationError{ 269 Err: fmt.Errorf("failed to decode response body, %w", err), 270 Snapshot: snapshot.Bytes(), 271 } 272 return err 273 } 274 275 errorBody.Seek(0, io.SeekStart) 276 if len(code) != 0 { 277 errorCode = restjson.SanitizeErrorCode(code) 278 } 279 if len(message) != 0 { 280 errorMessage = message 281 } 282 283 switch { 284 case strings.EqualFold("InvalidRequestException", errorCode): 285 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 286 287 case strings.EqualFold("ThrottledException", errorCode): 288 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 289 290 default: 291 genericError := &smithy.GenericAPIError{ 292 Code: errorCode, 293 Message: errorMessage, 294 } 295 return genericError 296 297 } 298} 299 300func awsRestjson1_deserializeOpDocumentCreateGroupOutput(v **CreateGroupOutput, value interface{}) error { 301 if v == nil { 302 return fmt.Errorf("unexpected nil of type %T", v) 303 } 304 if value == nil { 305 return nil 306 } 307 308 shape, ok := value.(map[string]interface{}) 309 if !ok { 310 return fmt.Errorf("unexpected JSON type %v", value) 311 } 312 313 var sv *CreateGroupOutput 314 if *v == nil { 315 sv = &CreateGroupOutput{} 316 } else { 317 sv = *v 318 } 319 320 for key, value := range shape { 321 switch key { 322 case "Group": 323 if err := awsRestjson1_deserializeDocumentGroup(&sv.Group, value); err != nil { 324 return err 325 } 326 327 default: 328 _, _ = key, value 329 330 } 331 } 332 *v = sv 333 return nil 334} 335 336type awsRestjson1_deserializeOpCreateSamplingRule struct { 337} 338 339func (*awsRestjson1_deserializeOpCreateSamplingRule) ID() string { 340 return "OperationDeserializer" 341} 342 343func (m *awsRestjson1_deserializeOpCreateSamplingRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 344 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 345) { 346 out, metadata, err = next.HandleDeserialize(ctx, in) 347 if err != nil { 348 return out, metadata, err 349 } 350 351 response, ok := out.RawResponse.(*smithyhttp.Response) 352 if !ok { 353 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 354 } 355 356 if response.StatusCode < 200 || response.StatusCode >= 300 { 357 return out, metadata, awsRestjson1_deserializeOpErrorCreateSamplingRule(response, &metadata) 358 } 359 output := &CreateSamplingRuleOutput{} 360 out.Result = output 361 362 var buff [1024]byte 363 ringBuffer := smithyio.NewRingBuffer(buff[:]) 364 365 body := io.TeeReader(response.Body, ringBuffer) 366 367 decoder := json.NewDecoder(body) 368 decoder.UseNumber() 369 var shape interface{} 370 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 371 var snapshot bytes.Buffer 372 io.Copy(&snapshot, ringBuffer) 373 err = &smithy.DeserializationError{ 374 Err: fmt.Errorf("failed to decode response body, %w", err), 375 Snapshot: snapshot.Bytes(), 376 } 377 return out, metadata, err 378 } 379 380 err = awsRestjson1_deserializeOpDocumentCreateSamplingRuleOutput(&output, shape) 381 if err != nil { 382 var snapshot bytes.Buffer 383 io.Copy(&snapshot, ringBuffer) 384 return out, metadata, &smithy.DeserializationError{ 385 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 386 Snapshot: snapshot.Bytes(), 387 } 388 } 389 390 return out, metadata, err 391} 392 393func awsRestjson1_deserializeOpErrorCreateSamplingRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 394 var errorBuffer bytes.Buffer 395 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 396 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 397 } 398 errorBody := bytes.NewReader(errorBuffer.Bytes()) 399 400 errorCode := "UnknownError" 401 errorMessage := errorCode 402 403 code := response.Header.Get("X-Amzn-ErrorType") 404 if len(code) != 0 { 405 errorCode = restjson.SanitizeErrorCode(code) 406 } 407 408 var buff [1024]byte 409 ringBuffer := smithyio.NewRingBuffer(buff[:]) 410 411 body := io.TeeReader(errorBody, ringBuffer) 412 decoder := json.NewDecoder(body) 413 decoder.UseNumber() 414 code, message, err := restjson.GetErrorInfo(decoder) 415 if err != nil { 416 var snapshot bytes.Buffer 417 io.Copy(&snapshot, ringBuffer) 418 err = &smithy.DeserializationError{ 419 Err: fmt.Errorf("failed to decode response body, %w", err), 420 Snapshot: snapshot.Bytes(), 421 } 422 return err 423 } 424 425 errorBody.Seek(0, io.SeekStart) 426 if len(code) != 0 { 427 errorCode = restjson.SanitizeErrorCode(code) 428 } 429 if len(message) != 0 { 430 errorMessage = message 431 } 432 433 switch { 434 case strings.EqualFold("InvalidRequestException", errorCode): 435 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 436 437 case strings.EqualFold("RuleLimitExceededException", errorCode): 438 return awsRestjson1_deserializeErrorRuleLimitExceededException(response, errorBody) 439 440 case strings.EqualFold("ThrottledException", errorCode): 441 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 442 443 default: 444 genericError := &smithy.GenericAPIError{ 445 Code: errorCode, 446 Message: errorMessage, 447 } 448 return genericError 449 450 } 451} 452 453func awsRestjson1_deserializeOpDocumentCreateSamplingRuleOutput(v **CreateSamplingRuleOutput, value interface{}) error { 454 if v == nil { 455 return fmt.Errorf("unexpected nil of type %T", v) 456 } 457 if value == nil { 458 return nil 459 } 460 461 shape, ok := value.(map[string]interface{}) 462 if !ok { 463 return fmt.Errorf("unexpected JSON type %v", value) 464 } 465 466 var sv *CreateSamplingRuleOutput 467 if *v == nil { 468 sv = &CreateSamplingRuleOutput{} 469 } else { 470 sv = *v 471 } 472 473 for key, value := range shape { 474 switch key { 475 case "SamplingRuleRecord": 476 if err := awsRestjson1_deserializeDocumentSamplingRuleRecord(&sv.SamplingRuleRecord, value); err != nil { 477 return err 478 } 479 480 default: 481 _, _ = key, value 482 483 } 484 } 485 *v = sv 486 return nil 487} 488 489type awsRestjson1_deserializeOpDeleteGroup struct { 490} 491 492func (*awsRestjson1_deserializeOpDeleteGroup) ID() string { 493 return "OperationDeserializer" 494} 495 496func (m *awsRestjson1_deserializeOpDeleteGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 497 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 498) { 499 out, metadata, err = next.HandleDeserialize(ctx, in) 500 if err != nil { 501 return out, metadata, err 502 } 503 504 response, ok := out.RawResponse.(*smithyhttp.Response) 505 if !ok { 506 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 507 } 508 509 if response.StatusCode < 200 || response.StatusCode >= 300 { 510 return out, metadata, awsRestjson1_deserializeOpErrorDeleteGroup(response, &metadata) 511 } 512 output := &DeleteGroupOutput{} 513 out.Result = output 514 515 return out, metadata, err 516} 517 518func awsRestjson1_deserializeOpErrorDeleteGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 519 var errorBuffer bytes.Buffer 520 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 521 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 522 } 523 errorBody := bytes.NewReader(errorBuffer.Bytes()) 524 525 errorCode := "UnknownError" 526 errorMessage := errorCode 527 528 code := response.Header.Get("X-Amzn-ErrorType") 529 if len(code) != 0 { 530 errorCode = restjson.SanitizeErrorCode(code) 531 } 532 533 var buff [1024]byte 534 ringBuffer := smithyio.NewRingBuffer(buff[:]) 535 536 body := io.TeeReader(errorBody, ringBuffer) 537 decoder := json.NewDecoder(body) 538 decoder.UseNumber() 539 code, message, err := restjson.GetErrorInfo(decoder) 540 if err != nil { 541 var snapshot bytes.Buffer 542 io.Copy(&snapshot, ringBuffer) 543 err = &smithy.DeserializationError{ 544 Err: fmt.Errorf("failed to decode response body, %w", err), 545 Snapshot: snapshot.Bytes(), 546 } 547 return err 548 } 549 550 errorBody.Seek(0, io.SeekStart) 551 if len(code) != 0 { 552 errorCode = restjson.SanitizeErrorCode(code) 553 } 554 if len(message) != 0 { 555 errorMessage = message 556 } 557 558 switch { 559 case strings.EqualFold("InvalidRequestException", errorCode): 560 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 561 562 case strings.EqualFold("ThrottledException", errorCode): 563 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 564 565 default: 566 genericError := &smithy.GenericAPIError{ 567 Code: errorCode, 568 Message: errorMessage, 569 } 570 return genericError 571 572 } 573} 574 575type awsRestjson1_deserializeOpDeleteSamplingRule struct { 576} 577 578func (*awsRestjson1_deserializeOpDeleteSamplingRule) ID() string { 579 return "OperationDeserializer" 580} 581 582func (m *awsRestjson1_deserializeOpDeleteSamplingRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 583 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 584) { 585 out, metadata, err = next.HandleDeserialize(ctx, in) 586 if err != nil { 587 return out, metadata, err 588 } 589 590 response, ok := out.RawResponse.(*smithyhttp.Response) 591 if !ok { 592 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 593 } 594 595 if response.StatusCode < 200 || response.StatusCode >= 300 { 596 return out, metadata, awsRestjson1_deserializeOpErrorDeleteSamplingRule(response, &metadata) 597 } 598 output := &DeleteSamplingRuleOutput{} 599 out.Result = output 600 601 var buff [1024]byte 602 ringBuffer := smithyio.NewRingBuffer(buff[:]) 603 604 body := io.TeeReader(response.Body, ringBuffer) 605 606 decoder := json.NewDecoder(body) 607 decoder.UseNumber() 608 var shape interface{} 609 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 610 var snapshot bytes.Buffer 611 io.Copy(&snapshot, ringBuffer) 612 err = &smithy.DeserializationError{ 613 Err: fmt.Errorf("failed to decode response body, %w", err), 614 Snapshot: snapshot.Bytes(), 615 } 616 return out, metadata, err 617 } 618 619 err = awsRestjson1_deserializeOpDocumentDeleteSamplingRuleOutput(&output, shape) 620 if err != nil { 621 var snapshot bytes.Buffer 622 io.Copy(&snapshot, ringBuffer) 623 return out, metadata, &smithy.DeserializationError{ 624 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 625 Snapshot: snapshot.Bytes(), 626 } 627 } 628 629 return out, metadata, err 630} 631 632func awsRestjson1_deserializeOpErrorDeleteSamplingRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 633 var errorBuffer bytes.Buffer 634 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 635 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 636 } 637 errorBody := bytes.NewReader(errorBuffer.Bytes()) 638 639 errorCode := "UnknownError" 640 errorMessage := errorCode 641 642 code := response.Header.Get("X-Amzn-ErrorType") 643 if len(code) != 0 { 644 errorCode = restjson.SanitizeErrorCode(code) 645 } 646 647 var buff [1024]byte 648 ringBuffer := smithyio.NewRingBuffer(buff[:]) 649 650 body := io.TeeReader(errorBody, ringBuffer) 651 decoder := json.NewDecoder(body) 652 decoder.UseNumber() 653 code, message, err := restjson.GetErrorInfo(decoder) 654 if err != nil { 655 var snapshot bytes.Buffer 656 io.Copy(&snapshot, ringBuffer) 657 err = &smithy.DeserializationError{ 658 Err: fmt.Errorf("failed to decode response body, %w", err), 659 Snapshot: snapshot.Bytes(), 660 } 661 return err 662 } 663 664 errorBody.Seek(0, io.SeekStart) 665 if len(code) != 0 { 666 errorCode = restjson.SanitizeErrorCode(code) 667 } 668 if len(message) != 0 { 669 errorMessage = message 670 } 671 672 switch { 673 case strings.EqualFold("InvalidRequestException", errorCode): 674 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 675 676 case strings.EqualFold("ThrottledException", errorCode): 677 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 678 679 default: 680 genericError := &smithy.GenericAPIError{ 681 Code: errorCode, 682 Message: errorMessage, 683 } 684 return genericError 685 686 } 687} 688 689func awsRestjson1_deserializeOpDocumentDeleteSamplingRuleOutput(v **DeleteSamplingRuleOutput, value interface{}) error { 690 if v == nil { 691 return fmt.Errorf("unexpected nil of type %T", v) 692 } 693 if value == nil { 694 return nil 695 } 696 697 shape, ok := value.(map[string]interface{}) 698 if !ok { 699 return fmt.Errorf("unexpected JSON type %v", value) 700 } 701 702 var sv *DeleteSamplingRuleOutput 703 if *v == nil { 704 sv = &DeleteSamplingRuleOutput{} 705 } else { 706 sv = *v 707 } 708 709 for key, value := range shape { 710 switch key { 711 case "SamplingRuleRecord": 712 if err := awsRestjson1_deserializeDocumentSamplingRuleRecord(&sv.SamplingRuleRecord, value); err != nil { 713 return err 714 } 715 716 default: 717 _, _ = key, value 718 719 } 720 } 721 *v = sv 722 return nil 723} 724 725type awsRestjson1_deserializeOpGetEncryptionConfig struct { 726} 727 728func (*awsRestjson1_deserializeOpGetEncryptionConfig) ID() string { 729 return "OperationDeserializer" 730} 731 732func (m *awsRestjson1_deserializeOpGetEncryptionConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 733 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 734) { 735 out, metadata, err = next.HandleDeserialize(ctx, in) 736 if err != nil { 737 return out, metadata, err 738 } 739 740 response, ok := out.RawResponse.(*smithyhttp.Response) 741 if !ok { 742 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 743 } 744 745 if response.StatusCode < 200 || response.StatusCode >= 300 { 746 return out, metadata, awsRestjson1_deserializeOpErrorGetEncryptionConfig(response, &metadata) 747 } 748 output := &GetEncryptionConfigOutput{} 749 out.Result = output 750 751 var buff [1024]byte 752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 753 754 body := io.TeeReader(response.Body, ringBuffer) 755 756 decoder := json.NewDecoder(body) 757 decoder.UseNumber() 758 var shape interface{} 759 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 760 var snapshot bytes.Buffer 761 io.Copy(&snapshot, ringBuffer) 762 err = &smithy.DeserializationError{ 763 Err: fmt.Errorf("failed to decode response body, %w", err), 764 Snapshot: snapshot.Bytes(), 765 } 766 return out, metadata, err 767 } 768 769 err = awsRestjson1_deserializeOpDocumentGetEncryptionConfigOutput(&output, shape) 770 if err != nil { 771 var snapshot bytes.Buffer 772 io.Copy(&snapshot, ringBuffer) 773 return out, metadata, &smithy.DeserializationError{ 774 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 775 Snapshot: snapshot.Bytes(), 776 } 777 } 778 779 return out, metadata, err 780} 781 782func awsRestjson1_deserializeOpErrorGetEncryptionConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 783 var errorBuffer bytes.Buffer 784 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 785 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 786 } 787 errorBody := bytes.NewReader(errorBuffer.Bytes()) 788 789 errorCode := "UnknownError" 790 errorMessage := errorCode 791 792 code := response.Header.Get("X-Amzn-ErrorType") 793 if len(code) != 0 { 794 errorCode = restjson.SanitizeErrorCode(code) 795 } 796 797 var buff [1024]byte 798 ringBuffer := smithyio.NewRingBuffer(buff[:]) 799 800 body := io.TeeReader(errorBody, ringBuffer) 801 decoder := json.NewDecoder(body) 802 decoder.UseNumber() 803 code, message, err := restjson.GetErrorInfo(decoder) 804 if err != nil { 805 var snapshot bytes.Buffer 806 io.Copy(&snapshot, ringBuffer) 807 err = &smithy.DeserializationError{ 808 Err: fmt.Errorf("failed to decode response body, %w", err), 809 Snapshot: snapshot.Bytes(), 810 } 811 return err 812 } 813 814 errorBody.Seek(0, io.SeekStart) 815 if len(code) != 0 { 816 errorCode = restjson.SanitizeErrorCode(code) 817 } 818 if len(message) != 0 { 819 errorMessage = message 820 } 821 822 switch { 823 case strings.EqualFold("InvalidRequestException", errorCode): 824 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 825 826 case strings.EqualFold("ThrottledException", errorCode): 827 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 828 829 default: 830 genericError := &smithy.GenericAPIError{ 831 Code: errorCode, 832 Message: errorMessage, 833 } 834 return genericError 835 836 } 837} 838 839func awsRestjson1_deserializeOpDocumentGetEncryptionConfigOutput(v **GetEncryptionConfigOutput, value interface{}) error { 840 if v == nil { 841 return fmt.Errorf("unexpected nil of type %T", v) 842 } 843 if value == nil { 844 return nil 845 } 846 847 shape, ok := value.(map[string]interface{}) 848 if !ok { 849 return fmt.Errorf("unexpected JSON type %v", value) 850 } 851 852 var sv *GetEncryptionConfigOutput 853 if *v == nil { 854 sv = &GetEncryptionConfigOutput{} 855 } else { 856 sv = *v 857 } 858 859 for key, value := range shape { 860 switch key { 861 case "EncryptionConfig": 862 if err := awsRestjson1_deserializeDocumentEncryptionConfig(&sv.EncryptionConfig, value); err != nil { 863 return err 864 } 865 866 default: 867 _, _ = key, value 868 869 } 870 } 871 *v = sv 872 return nil 873} 874 875type awsRestjson1_deserializeOpGetGroup struct { 876} 877 878func (*awsRestjson1_deserializeOpGetGroup) ID() string { 879 return "OperationDeserializer" 880} 881 882func (m *awsRestjson1_deserializeOpGetGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 883 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 884) { 885 out, metadata, err = next.HandleDeserialize(ctx, in) 886 if err != nil { 887 return out, metadata, err 888 } 889 890 response, ok := out.RawResponse.(*smithyhttp.Response) 891 if !ok { 892 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 893 } 894 895 if response.StatusCode < 200 || response.StatusCode >= 300 { 896 return out, metadata, awsRestjson1_deserializeOpErrorGetGroup(response, &metadata) 897 } 898 output := &GetGroupOutput{} 899 out.Result = output 900 901 var buff [1024]byte 902 ringBuffer := smithyio.NewRingBuffer(buff[:]) 903 904 body := io.TeeReader(response.Body, ringBuffer) 905 906 decoder := json.NewDecoder(body) 907 decoder.UseNumber() 908 var shape interface{} 909 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 910 var snapshot bytes.Buffer 911 io.Copy(&snapshot, ringBuffer) 912 err = &smithy.DeserializationError{ 913 Err: fmt.Errorf("failed to decode response body, %w", err), 914 Snapshot: snapshot.Bytes(), 915 } 916 return out, metadata, err 917 } 918 919 err = awsRestjson1_deserializeOpDocumentGetGroupOutput(&output, shape) 920 if err != nil { 921 var snapshot bytes.Buffer 922 io.Copy(&snapshot, ringBuffer) 923 return out, metadata, &smithy.DeserializationError{ 924 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 925 Snapshot: snapshot.Bytes(), 926 } 927 } 928 929 return out, metadata, err 930} 931 932func awsRestjson1_deserializeOpErrorGetGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 933 var errorBuffer bytes.Buffer 934 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 935 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 936 } 937 errorBody := bytes.NewReader(errorBuffer.Bytes()) 938 939 errorCode := "UnknownError" 940 errorMessage := errorCode 941 942 code := response.Header.Get("X-Amzn-ErrorType") 943 if len(code) != 0 { 944 errorCode = restjson.SanitizeErrorCode(code) 945 } 946 947 var buff [1024]byte 948 ringBuffer := smithyio.NewRingBuffer(buff[:]) 949 950 body := io.TeeReader(errorBody, ringBuffer) 951 decoder := json.NewDecoder(body) 952 decoder.UseNumber() 953 code, message, err := restjson.GetErrorInfo(decoder) 954 if err != nil { 955 var snapshot bytes.Buffer 956 io.Copy(&snapshot, ringBuffer) 957 err = &smithy.DeserializationError{ 958 Err: fmt.Errorf("failed to decode response body, %w", err), 959 Snapshot: snapshot.Bytes(), 960 } 961 return err 962 } 963 964 errorBody.Seek(0, io.SeekStart) 965 if len(code) != 0 { 966 errorCode = restjson.SanitizeErrorCode(code) 967 } 968 if len(message) != 0 { 969 errorMessage = message 970 } 971 972 switch { 973 case strings.EqualFold("InvalidRequestException", errorCode): 974 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 975 976 case strings.EqualFold("ThrottledException", errorCode): 977 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 978 979 default: 980 genericError := &smithy.GenericAPIError{ 981 Code: errorCode, 982 Message: errorMessage, 983 } 984 return genericError 985 986 } 987} 988 989func awsRestjson1_deserializeOpDocumentGetGroupOutput(v **GetGroupOutput, value interface{}) error { 990 if v == nil { 991 return fmt.Errorf("unexpected nil of type %T", v) 992 } 993 if value == nil { 994 return nil 995 } 996 997 shape, ok := value.(map[string]interface{}) 998 if !ok { 999 return fmt.Errorf("unexpected JSON type %v", value) 1000 } 1001 1002 var sv *GetGroupOutput 1003 if *v == nil { 1004 sv = &GetGroupOutput{} 1005 } else { 1006 sv = *v 1007 } 1008 1009 for key, value := range shape { 1010 switch key { 1011 case "Group": 1012 if err := awsRestjson1_deserializeDocumentGroup(&sv.Group, value); err != nil { 1013 return err 1014 } 1015 1016 default: 1017 _, _ = key, value 1018 1019 } 1020 } 1021 *v = sv 1022 return nil 1023} 1024 1025type awsRestjson1_deserializeOpGetGroups struct { 1026} 1027 1028func (*awsRestjson1_deserializeOpGetGroups) ID() string { 1029 return "OperationDeserializer" 1030} 1031 1032func (m *awsRestjson1_deserializeOpGetGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1033 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1034) { 1035 out, metadata, err = next.HandleDeserialize(ctx, in) 1036 if err != nil { 1037 return out, metadata, err 1038 } 1039 1040 response, ok := out.RawResponse.(*smithyhttp.Response) 1041 if !ok { 1042 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1043 } 1044 1045 if response.StatusCode < 200 || response.StatusCode >= 300 { 1046 return out, metadata, awsRestjson1_deserializeOpErrorGetGroups(response, &metadata) 1047 } 1048 output := &GetGroupsOutput{} 1049 out.Result = output 1050 1051 var buff [1024]byte 1052 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1053 1054 body := io.TeeReader(response.Body, ringBuffer) 1055 1056 decoder := json.NewDecoder(body) 1057 decoder.UseNumber() 1058 var shape interface{} 1059 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1060 var snapshot bytes.Buffer 1061 io.Copy(&snapshot, ringBuffer) 1062 err = &smithy.DeserializationError{ 1063 Err: fmt.Errorf("failed to decode response body, %w", err), 1064 Snapshot: snapshot.Bytes(), 1065 } 1066 return out, metadata, err 1067 } 1068 1069 err = awsRestjson1_deserializeOpDocumentGetGroupsOutput(&output, shape) 1070 if err != nil { 1071 var snapshot bytes.Buffer 1072 io.Copy(&snapshot, ringBuffer) 1073 return out, metadata, &smithy.DeserializationError{ 1074 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1075 Snapshot: snapshot.Bytes(), 1076 } 1077 } 1078 1079 return out, metadata, err 1080} 1081 1082func awsRestjson1_deserializeOpErrorGetGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1083 var errorBuffer bytes.Buffer 1084 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1085 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1086 } 1087 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1088 1089 errorCode := "UnknownError" 1090 errorMessage := errorCode 1091 1092 code := response.Header.Get("X-Amzn-ErrorType") 1093 if len(code) != 0 { 1094 errorCode = restjson.SanitizeErrorCode(code) 1095 } 1096 1097 var buff [1024]byte 1098 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1099 1100 body := io.TeeReader(errorBody, ringBuffer) 1101 decoder := json.NewDecoder(body) 1102 decoder.UseNumber() 1103 code, message, err := restjson.GetErrorInfo(decoder) 1104 if err != nil { 1105 var snapshot bytes.Buffer 1106 io.Copy(&snapshot, ringBuffer) 1107 err = &smithy.DeserializationError{ 1108 Err: fmt.Errorf("failed to decode response body, %w", err), 1109 Snapshot: snapshot.Bytes(), 1110 } 1111 return err 1112 } 1113 1114 errorBody.Seek(0, io.SeekStart) 1115 if len(code) != 0 { 1116 errorCode = restjson.SanitizeErrorCode(code) 1117 } 1118 if len(message) != 0 { 1119 errorMessage = message 1120 } 1121 1122 switch { 1123 case strings.EqualFold("InvalidRequestException", errorCode): 1124 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1125 1126 case strings.EqualFold("ThrottledException", errorCode): 1127 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1128 1129 default: 1130 genericError := &smithy.GenericAPIError{ 1131 Code: errorCode, 1132 Message: errorMessage, 1133 } 1134 return genericError 1135 1136 } 1137} 1138 1139func awsRestjson1_deserializeOpDocumentGetGroupsOutput(v **GetGroupsOutput, value interface{}) error { 1140 if v == nil { 1141 return fmt.Errorf("unexpected nil of type %T", v) 1142 } 1143 if value == nil { 1144 return nil 1145 } 1146 1147 shape, ok := value.(map[string]interface{}) 1148 if !ok { 1149 return fmt.Errorf("unexpected JSON type %v", value) 1150 } 1151 1152 var sv *GetGroupsOutput 1153 if *v == nil { 1154 sv = &GetGroupsOutput{} 1155 } else { 1156 sv = *v 1157 } 1158 1159 for key, value := range shape { 1160 switch key { 1161 case "Groups": 1162 if err := awsRestjson1_deserializeDocumentGroupSummaryList(&sv.Groups, value); err != nil { 1163 return err 1164 } 1165 1166 case "NextToken": 1167 if value != nil { 1168 jtv, ok := value.(string) 1169 if !ok { 1170 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1171 } 1172 sv.NextToken = ptr.String(jtv) 1173 } 1174 1175 default: 1176 _, _ = key, value 1177 1178 } 1179 } 1180 *v = sv 1181 return nil 1182} 1183 1184type awsRestjson1_deserializeOpGetInsight struct { 1185} 1186 1187func (*awsRestjson1_deserializeOpGetInsight) ID() string { 1188 return "OperationDeserializer" 1189} 1190 1191func (m *awsRestjson1_deserializeOpGetInsight) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1192 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1193) { 1194 out, metadata, err = next.HandleDeserialize(ctx, in) 1195 if err != nil { 1196 return out, metadata, err 1197 } 1198 1199 response, ok := out.RawResponse.(*smithyhttp.Response) 1200 if !ok { 1201 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1202 } 1203 1204 if response.StatusCode < 200 || response.StatusCode >= 300 { 1205 return out, metadata, awsRestjson1_deserializeOpErrorGetInsight(response, &metadata) 1206 } 1207 output := &GetInsightOutput{} 1208 out.Result = output 1209 1210 var buff [1024]byte 1211 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1212 1213 body := io.TeeReader(response.Body, ringBuffer) 1214 1215 decoder := json.NewDecoder(body) 1216 decoder.UseNumber() 1217 var shape interface{} 1218 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1219 var snapshot bytes.Buffer 1220 io.Copy(&snapshot, ringBuffer) 1221 err = &smithy.DeserializationError{ 1222 Err: fmt.Errorf("failed to decode response body, %w", err), 1223 Snapshot: snapshot.Bytes(), 1224 } 1225 return out, metadata, err 1226 } 1227 1228 err = awsRestjson1_deserializeOpDocumentGetInsightOutput(&output, shape) 1229 if err != nil { 1230 var snapshot bytes.Buffer 1231 io.Copy(&snapshot, ringBuffer) 1232 return out, metadata, &smithy.DeserializationError{ 1233 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1234 Snapshot: snapshot.Bytes(), 1235 } 1236 } 1237 1238 return out, metadata, err 1239} 1240 1241func awsRestjson1_deserializeOpErrorGetInsight(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1242 var errorBuffer bytes.Buffer 1243 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1244 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1245 } 1246 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1247 1248 errorCode := "UnknownError" 1249 errorMessage := errorCode 1250 1251 code := response.Header.Get("X-Amzn-ErrorType") 1252 if len(code) != 0 { 1253 errorCode = restjson.SanitizeErrorCode(code) 1254 } 1255 1256 var buff [1024]byte 1257 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1258 1259 body := io.TeeReader(errorBody, ringBuffer) 1260 decoder := json.NewDecoder(body) 1261 decoder.UseNumber() 1262 code, message, err := restjson.GetErrorInfo(decoder) 1263 if err != nil { 1264 var snapshot bytes.Buffer 1265 io.Copy(&snapshot, ringBuffer) 1266 err = &smithy.DeserializationError{ 1267 Err: fmt.Errorf("failed to decode response body, %w", err), 1268 Snapshot: snapshot.Bytes(), 1269 } 1270 return err 1271 } 1272 1273 errorBody.Seek(0, io.SeekStart) 1274 if len(code) != 0 { 1275 errorCode = restjson.SanitizeErrorCode(code) 1276 } 1277 if len(message) != 0 { 1278 errorMessage = message 1279 } 1280 1281 switch { 1282 case strings.EqualFold("InvalidRequestException", errorCode): 1283 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1284 1285 case strings.EqualFold("ThrottledException", errorCode): 1286 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1287 1288 default: 1289 genericError := &smithy.GenericAPIError{ 1290 Code: errorCode, 1291 Message: errorMessage, 1292 } 1293 return genericError 1294 1295 } 1296} 1297 1298func awsRestjson1_deserializeOpDocumentGetInsightOutput(v **GetInsightOutput, value interface{}) error { 1299 if v == nil { 1300 return fmt.Errorf("unexpected nil of type %T", v) 1301 } 1302 if value == nil { 1303 return nil 1304 } 1305 1306 shape, ok := value.(map[string]interface{}) 1307 if !ok { 1308 return fmt.Errorf("unexpected JSON type %v", value) 1309 } 1310 1311 var sv *GetInsightOutput 1312 if *v == nil { 1313 sv = &GetInsightOutput{} 1314 } else { 1315 sv = *v 1316 } 1317 1318 for key, value := range shape { 1319 switch key { 1320 case "Insight": 1321 if err := awsRestjson1_deserializeDocumentInsight(&sv.Insight, value); err != nil { 1322 return err 1323 } 1324 1325 default: 1326 _, _ = key, value 1327 1328 } 1329 } 1330 *v = sv 1331 return nil 1332} 1333 1334type awsRestjson1_deserializeOpGetInsightEvents struct { 1335} 1336 1337func (*awsRestjson1_deserializeOpGetInsightEvents) ID() string { 1338 return "OperationDeserializer" 1339} 1340 1341func (m *awsRestjson1_deserializeOpGetInsightEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1342 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1343) { 1344 out, metadata, err = next.HandleDeserialize(ctx, in) 1345 if err != nil { 1346 return out, metadata, err 1347 } 1348 1349 response, ok := out.RawResponse.(*smithyhttp.Response) 1350 if !ok { 1351 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1352 } 1353 1354 if response.StatusCode < 200 || response.StatusCode >= 300 { 1355 return out, metadata, awsRestjson1_deserializeOpErrorGetInsightEvents(response, &metadata) 1356 } 1357 output := &GetInsightEventsOutput{} 1358 out.Result = output 1359 1360 var buff [1024]byte 1361 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1362 1363 body := io.TeeReader(response.Body, ringBuffer) 1364 1365 decoder := json.NewDecoder(body) 1366 decoder.UseNumber() 1367 var shape interface{} 1368 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1369 var snapshot bytes.Buffer 1370 io.Copy(&snapshot, ringBuffer) 1371 err = &smithy.DeserializationError{ 1372 Err: fmt.Errorf("failed to decode response body, %w", err), 1373 Snapshot: snapshot.Bytes(), 1374 } 1375 return out, metadata, err 1376 } 1377 1378 err = awsRestjson1_deserializeOpDocumentGetInsightEventsOutput(&output, shape) 1379 if err != nil { 1380 var snapshot bytes.Buffer 1381 io.Copy(&snapshot, ringBuffer) 1382 return out, metadata, &smithy.DeserializationError{ 1383 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1384 Snapshot: snapshot.Bytes(), 1385 } 1386 } 1387 1388 return out, metadata, err 1389} 1390 1391func awsRestjson1_deserializeOpErrorGetInsightEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1392 var errorBuffer bytes.Buffer 1393 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1394 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1395 } 1396 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1397 1398 errorCode := "UnknownError" 1399 errorMessage := errorCode 1400 1401 code := response.Header.Get("X-Amzn-ErrorType") 1402 if len(code) != 0 { 1403 errorCode = restjson.SanitizeErrorCode(code) 1404 } 1405 1406 var buff [1024]byte 1407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1408 1409 body := io.TeeReader(errorBody, ringBuffer) 1410 decoder := json.NewDecoder(body) 1411 decoder.UseNumber() 1412 code, message, err := restjson.GetErrorInfo(decoder) 1413 if err != nil { 1414 var snapshot bytes.Buffer 1415 io.Copy(&snapshot, ringBuffer) 1416 err = &smithy.DeserializationError{ 1417 Err: fmt.Errorf("failed to decode response body, %w", err), 1418 Snapshot: snapshot.Bytes(), 1419 } 1420 return err 1421 } 1422 1423 errorBody.Seek(0, io.SeekStart) 1424 if len(code) != 0 { 1425 errorCode = restjson.SanitizeErrorCode(code) 1426 } 1427 if len(message) != 0 { 1428 errorMessage = message 1429 } 1430 1431 switch { 1432 case strings.EqualFold("InvalidRequestException", errorCode): 1433 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1434 1435 case strings.EqualFold("ThrottledException", errorCode): 1436 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1437 1438 default: 1439 genericError := &smithy.GenericAPIError{ 1440 Code: errorCode, 1441 Message: errorMessage, 1442 } 1443 return genericError 1444 1445 } 1446} 1447 1448func awsRestjson1_deserializeOpDocumentGetInsightEventsOutput(v **GetInsightEventsOutput, value interface{}) error { 1449 if v == nil { 1450 return fmt.Errorf("unexpected nil of type %T", v) 1451 } 1452 if value == nil { 1453 return nil 1454 } 1455 1456 shape, ok := value.(map[string]interface{}) 1457 if !ok { 1458 return fmt.Errorf("unexpected JSON type %v", value) 1459 } 1460 1461 var sv *GetInsightEventsOutput 1462 if *v == nil { 1463 sv = &GetInsightEventsOutput{} 1464 } else { 1465 sv = *v 1466 } 1467 1468 for key, value := range shape { 1469 switch key { 1470 case "InsightEvents": 1471 if err := awsRestjson1_deserializeDocumentInsightEventList(&sv.InsightEvents, value); err != nil { 1472 return err 1473 } 1474 1475 case "NextToken": 1476 if value != nil { 1477 jtv, ok := value.(string) 1478 if !ok { 1479 return fmt.Errorf("expected Token to be of type string, got %T instead", value) 1480 } 1481 sv.NextToken = ptr.String(jtv) 1482 } 1483 1484 default: 1485 _, _ = key, value 1486 1487 } 1488 } 1489 *v = sv 1490 return nil 1491} 1492 1493type awsRestjson1_deserializeOpGetInsightImpactGraph struct { 1494} 1495 1496func (*awsRestjson1_deserializeOpGetInsightImpactGraph) ID() string { 1497 return "OperationDeserializer" 1498} 1499 1500func (m *awsRestjson1_deserializeOpGetInsightImpactGraph) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1501 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1502) { 1503 out, metadata, err = next.HandleDeserialize(ctx, in) 1504 if err != nil { 1505 return out, metadata, err 1506 } 1507 1508 response, ok := out.RawResponse.(*smithyhttp.Response) 1509 if !ok { 1510 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1511 } 1512 1513 if response.StatusCode < 200 || response.StatusCode >= 300 { 1514 return out, metadata, awsRestjson1_deserializeOpErrorGetInsightImpactGraph(response, &metadata) 1515 } 1516 output := &GetInsightImpactGraphOutput{} 1517 out.Result = output 1518 1519 var buff [1024]byte 1520 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1521 1522 body := io.TeeReader(response.Body, ringBuffer) 1523 1524 decoder := json.NewDecoder(body) 1525 decoder.UseNumber() 1526 var shape interface{} 1527 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1528 var snapshot bytes.Buffer 1529 io.Copy(&snapshot, ringBuffer) 1530 err = &smithy.DeserializationError{ 1531 Err: fmt.Errorf("failed to decode response body, %w", err), 1532 Snapshot: snapshot.Bytes(), 1533 } 1534 return out, metadata, err 1535 } 1536 1537 err = awsRestjson1_deserializeOpDocumentGetInsightImpactGraphOutput(&output, shape) 1538 if err != nil { 1539 var snapshot bytes.Buffer 1540 io.Copy(&snapshot, ringBuffer) 1541 return out, metadata, &smithy.DeserializationError{ 1542 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1543 Snapshot: snapshot.Bytes(), 1544 } 1545 } 1546 1547 return out, metadata, err 1548} 1549 1550func awsRestjson1_deserializeOpErrorGetInsightImpactGraph(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1551 var errorBuffer bytes.Buffer 1552 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1553 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1554 } 1555 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1556 1557 errorCode := "UnknownError" 1558 errorMessage := errorCode 1559 1560 code := response.Header.Get("X-Amzn-ErrorType") 1561 if len(code) != 0 { 1562 errorCode = restjson.SanitizeErrorCode(code) 1563 } 1564 1565 var buff [1024]byte 1566 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1567 1568 body := io.TeeReader(errorBody, ringBuffer) 1569 decoder := json.NewDecoder(body) 1570 decoder.UseNumber() 1571 code, message, err := restjson.GetErrorInfo(decoder) 1572 if err != nil { 1573 var snapshot bytes.Buffer 1574 io.Copy(&snapshot, ringBuffer) 1575 err = &smithy.DeserializationError{ 1576 Err: fmt.Errorf("failed to decode response body, %w", err), 1577 Snapshot: snapshot.Bytes(), 1578 } 1579 return err 1580 } 1581 1582 errorBody.Seek(0, io.SeekStart) 1583 if len(code) != 0 { 1584 errorCode = restjson.SanitizeErrorCode(code) 1585 } 1586 if len(message) != 0 { 1587 errorMessage = message 1588 } 1589 1590 switch { 1591 case strings.EqualFold("InvalidRequestException", errorCode): 1592 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1593 1594 case strings.EqualFold("ThrottledException", errorCode): 1595 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1596 1597 default: 1598 genericError := &smithy.GenericAPIError{ 1599 Code: errorCode, 1600 Message: errorMessage, 1601 } 1602 return genericError 1603 1604 } 1605} 1606 1607func awsRestjson1_deserializeOpDocumentGetInsightImpactGraphOutput(v **GetInsightImpactGraphOutput, value interface{}) error { 1608 if v == nil { 1609 return fmt.Errorf("unexpected nil of type %T", v) 1610 } 1611 if value == nil { 1612 return nil 1613 } 1614 1615 shape, ok := value.(map[string]interface{}) 1616 if !ok { 1617 return fmt.Errorf("unexpected JSON type %v", value) 1618 } 1619 1620 var sv *GetInsightImpactGraphOutput 1621 if *v == nil { 1622 sv = &GetInsightImpactGraphOutput{} 1623 } else { 1624 sv = *v 1625 } 1626 1627 for key, value := range shape { 1628 switch key { 1629 case "EndTime": 1630 if value != nil { 1631 jtv, ok := value.(json.Number) 1632 if !ok { 1633 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 1634 } 1635 f64, err := jtv.Float64() 1636 if err != nil { 1637 return err 1638 } 1639 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1640 } 1641 1642 case "InsightId": 1643 if value != nil { 1644 jtv, ok := value.(string) 1645 if !ok { 1646 return fmt.Errorf("expected InsightId to be of type string, got %T instead", value) 1647 } 1648 sv.InsightId = ptr.String(jtv) 1649 } 1650 1651 case "NextToken": 1652 if value != nil { 1653 jtv, ok := value.(string) 1654 if !ok { 1655 return fmt.Errorf("expected Token to be of type string, got %T instead", value) 1656 } 1657 sv.NextToken = ptr.String(jtv) 1658 } 1659 1660 case "ServiceGraphEndTime": 1661 if value != nil { 1662 jtv, ok := value.(json.Number) 1663 if !ok { 1664 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 1665 } 1666 f64, err := jtv.Float64() 1667 if err != nil { 1668 return err 1669 } 1670 sv.ServiceGraphEndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1671 } 1672 1673 case "ServiceGraphStartTime": 1674 if value != nil { 1675 jtv, ok := value.(json.Number) 1676 if !ok { 1677 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 1678 } 1679 f64, err := jtv.Float64() 1680 if err != nil { 1681 return err 1682 } 1683 sv.ServiceGraphStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1684 } 1685 1686 case "Services": 1687 if err := awsRestjson1_deserializeDocumentInsightImpactGraphServiceList(&sv.Services, value); err != nil { 1688 return err 1689 } 1690 1691 case "StartTime": 1692 if value != nil { 1693 jtv, ok := value.(json.Number) 1694 if !ok { 1695 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 1696 } 1697 f64, err := jtv.Float64() 1698 if err != nil { 1699 return err 1700 } 1701 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1702 } 1703 1704 default: 1705 _, _ = key, value 1706 1707 } 1708 } 1709 *v = sv 1710 return nil 1711} 1712 1713type awsRestjson1_deserializeOpGetInsightSummaries struct { 1714} 1715 1716func (*awsRestjson1_deserializeOpGetInsightSummaries) ID() string { 1717 return "OperationDeserializer" 1718} 1719 1720func (m *awsRestjson1_deserializeOpGetInsightSummaries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1721 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1722) { 1723 out, metadata, err = next.HandleDeserialize(ctx, in) 1724 if err != nil { 1725 return out, metadata, err 1726 } 1727 1728 response, ok := out.RawResponse.(*smithyhttp.Response) 1729 if !ok { 1730 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1731 } 1732 1733 if response.StatusCode < 200 || response.StatusCode >= 300 { 1734 return out, metadata, awsRestjson1_deserializeOpErrorGetInsightSummaries(response, &metadata) 1735 } 1736 output := &GetInsightSummariesOutput{} 1737 out.Result = output 1738 1739 var buff [1024]byte 1740 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1741 1742 body := io.TeeReader(response.Body, ringBuffer) 1743 1744 decoder := json.NewDecoder(body) 1745 decoder.UseNumber() 1746 var shape interface{} 1747 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1748 var snapshot bytes.Buffer 1749 io.Copy(&snapshot, ringBuffer) 1750 err = &smithy.DeserializationError{ 1751 Err: fmt.Errorf("failed to decode response body, %w", err), 1752 Snapshot: snapshot.Bytes(), 1753 } 1754 return out, metadata, err 1755 } 1756 1757 err = awsRestjson1_deserializeOpDocumentGetInsightSummariesOutput(&output, shape) 1758 if err != nil { 1759 var snapshot bytes.Buffer 1760 io.Copy(&snapshot, ringBuffer) 1761 return out, metadata, &smithy.DeserializationError{ 1762 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1763 Snapshot: snapshot.Bytes(), 1764 } 1765 } 1766 1767 return out, metadata, err 1768} 1769 1770func awsRestjson1_deserializeOpErrorGetInsightSummaries(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1771 var errorBuffer bytes.Buffer 1772 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1773 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1774 } 1775 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1776 1777 errorCode := "UnknownError" 1778 errorMessage := errorCode 1779 1780 code := response.Header.Get("X-Amzn-ErrorType") 1781 if len(code) != 0 { 1782 errorCode = restjson.SanitizeErrorCode(code) 1783 } 1784 1785 var buff [1024]byte 1786 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1787 1788 body := io.TeeReader(errorBody, ringBuffer) 1789 decoder := json.NewDecoder(body) 1790 decoder.UseNumber() 1791 code, message, err := restjson.GetErrorInfo(decoder) 1792 if err != nil { 1793 var snapshot bytes.Buffer 1794 io.Copy(&snapshot, ringBuffer) 1795 err = &smithy.DeserializationError{ 1796 Err: fmt.Errorf("failed to decode response body, %w", err), 1797 Snapshot: snapshot.Bytes(), 1798 } 1799 return err 1800 } 1801 1802 errorBody.Seek(0, io.SeekStart) 1803 if len(code) != 0 { 1804 errorCode = restjson.SanitizeErrorCode(code) 1805 } 1806 if len(message) != 0 { 1807 errorMessage = message 1808 } 1809 1810 switch { 1811 case strings.EqualFold("InvalidRequestException", errorCode): 1812 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1813 1814 case strings.EqualFold("ThrottledException", errorCode): 1815 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1816 1817 default: 1818 genericError := &smithy.GenericAPIError{ 1819 Code: errorCode, 1820 Message: errorMessage, 1821 } 1822 return genericError 1823 1824 } 1825} 1826 1827func awsRestjson1_deserializeOpDocumentGetInsightSummariesOutput(v **GetInsightSummariesOutput, value interface{}) error { 1828 if v == nil { 1829 return fmt.Errorf("unexpected nil of type %T", v) 1830 } 1831 if value == nil { 1832 return nil 1833 } 1834 1835 shape, ok := value.(map[string]interface{}) 1836 if !ok { 1837 return fmt.Errorf("unexpected JSON type %v", value) 1838 } 1839 1840 var sv *GetInsightSummariesOutput 1841 if *v == nil { 1842 sv = &GetInsightSummariesOutput{} 1843 } else { 1844 sv = *v 1845 } 1846 1847 for key, value := range shape { 1848 switch key { 1849 case "InsightSummaries": 1850 if err := awsRestjson1_deserializeDocumentInsightSummaryList(&sv.InsightSummaries, value); err != nil { 1851 return err 1852 } 1853 1854 case "NextToken": 1855 if value != nil { 1856 jtv, ok := value.(string) 1857 if !ok { 1858 return fmt.Errorf("expected Token to be of type string, got %T instead", value) 1859 } 1860 sv.NextToken = ptr.String(jtv) 1861 } 1862 1863 default: 1864 _, _ = key, value 1865 1866 } 1867 } 1868 *v = sv 1869 return nil 1870} 1871 1872type awsRestjson1_deserializeOpGetSamplingRules struct { 1873} 1874 1875func (*awsRestjson1_deserializeOpGetSamplingRules) ID() string { 1876 return "OperationDeserializer" 1877} 1878 1879func (m *awsRestjson1_deserializeOpGetSamplingRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1880 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1881) { 1882 out, metadata, err = next.HandleDeserialize(ctx, in) 1883 if err != nil { 1884 return out, metadata, err 1885 } 1886 1887 response, ok := out.RawResponse.(*smithyhttp.Response) 1888 if !ok { 1889 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1890 } 1891 1892 if response.StatusCode < 200 || response.StatusCode >= 300 { 1893 return out, metadata, awsRestjson1_deserializeOpErrorGetSamplingRules(response, &metadata) 1894 } 1895 output := &GetSamplingRulesOutput{} 1896 out.Result = output 1897 1898 var buff [1024]byte 1899 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1900 1901 body := io.TeeReader(response.Body, ringBuffer) 1902 1903 decoder := json.NewDecoder(body) 1904 decoder.UseNumber() 1905 var shape interface{} 1906 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1907 var snapshot bytes.Buffer 1908 io.Copy(&snapshot, ringBuffer) 1909 err = &smithy.DeserializationError{ 1910 Err: fmt.Errorf("failed to decode response body, %w", err), 1911 Snapshot: snapshot.Bytes(), 1912 } 1913 return out, metadata, err 1914 } 1915 1916 err = awsRestjson1_deserializeOpDocumentGetSamplingRulesOutput(&output, shape) 1917 if err != nil { 1918 var snapshot bytes.Buffer 1919 io.Copy(&snapshot, ringBuffer) 1920 return out, metadata, &smithy.DeserializationError{ 1921 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1922 Snapshot: snapshot.Bytes(), 1923 } 1924 } 1925 1926 return out, metadata, err 1927} 1928 1929func awsRestjson1_deserializeOpErrorGetSamplingRules(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1930 var errorBuffer bytes.Buffer 1931 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1932 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1933 } 1934 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1935 1936 errorCode := "UnknownError" 1937 errorMessage := errorCode 1938 1939 code := response.Header.Get("X-Amzn-ErrorType") 1940 if len(code) != 0 { 1941 errorCode = restjson.SanitizeErrorCode(code) 1942 } 1943 1944 var buff [1024]byte 1945 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1946 1947 body := io.TeeReader(errorBody, ringBuffer) 1948 decoder := json.NewDecoder(body) 1949 decoder.UseNumber() 1950 code, message, err := restjson.GetErrorInfo(decoder) 1951 if err != nil { 1952 var snapshot bytes.Buffer 1953 io.Copy(&snapshot, ringBuffer) 1954 err = &smithy.DeserializationError{ 1955 Err: fmt.Errorf("failed to decode response body, %w", err), 1956 Snapshot: snapshot.Bytes(), 1957 } 1958 return err 1959 } 1960 1961 errorBody.Seek(0, io.SeekStart) 1962 if len(code) != 0 { 1963 errorCode = restjson.SanitizeErrorCode(code) 1964 } 1965 if len(message) != 0 { 1966 errorMessage = message 1967 } 1968 1969 switch { 1970 case strings.EqualFold("InvalidRequestException", errorCode): 1971 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 1972 1973 case strings.EqualFold("ThrottledException", errorCode): 1974 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 1975 1976 default: 1977 genericError := &smithy.GenericAPIError{ 1978 Code: errorCode, 1979 Message: errorMessage, 1980 } 1981 return genericError 1982 1983 } 1984} 1985 1986func awsRestjson1_deserializeOpDocumentGetSamplingRulesOutput(v **GetSamplingRulesOutput, value interface{}) error { 1987 if v == nil { 1988 return fmt.Errorf("unexpected nil of type %T", v) 1989 } 1990 if value == nil { 1991 return nil 1992 } 1993 1994 shape, ok := value.(map[string]interface{}) 1995 if !ok { 1996 return fmt.Errorf("unexpected JSON type %v", value) 1997 } 1998 1999 var sv *GetSamplingRulesOutput 2000 if *v == nil { 2001 sv = &GetSamplingRulesOutput{} 2002 } else { 2003 sv = *v 2004 } 2005 2006 for key, value := range shape { 2007 switch key { 2008 case "NextToken": 2009 if value != nil { 2010 jtv, ok := value.(string) 2011 if !ok { 2012 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2013 } 2014 sv.NextToken = ptr.String(jtv) 2015 } 2016 2017 case "SamplingRuleRecords": 2018 if err := awsRestjson1_deserializeDocumentSamplingRuleRecordList(&sv.SamplingRuleRecords, value); err != nil { 2019 return err 2020 } 2021 2022 default: 2023 _, _ = key, value 2024 2025 } 2026 } 2027 *v = sv 2028 return nil 2029} 2030 2031type awsRestjson1_deserializeOpGetSamplingStatisticSummaries struct { 2032} 2033 2034func (*awsRestjson1_deserializeOpGetSamplingStatisticSummaries) ID() string { 2035 return "OperationDeserializer" 2036} 2037 2038func (m *awsRestjson1_deserializeOpGetSamplingStatisticSummaries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2039 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2040) { 2041 out, metadata, err = next.HandleDeserialize(ctx, in) 2042 if err != nil { 2043 return out, metadata, err 2044 } 2045 2046 response, ok := out.RawResponse.(*smithyhttp.Response) 2047 if !ok { 2048 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2049 } 2050 2051 if response.StatusCode < 200 || response.StatusCode >= 300 { 2052 return out, metadata, awsRestjson1_deserializeOpErrorGetSamplingStatisticSummaries(response, &metadata) 2053 } 2054 output := &GetSamplingStatisticSummariesOutput{} 2055 out.Result = output 2056 2057 var buff [1024]byte 2058 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2059 2060 body := io.TeeReader(response.Body, ringBuffer) 2061 2062 decoder := json.NewDecoder(body) 2063 decoder.UseNumber() 2064 var shape interface{} 2065 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2066 var snapshot bytes.Buffer 2067 io.Copy(&snapshot, ringBuffer) 2068 err = &smithy.DeserializationError{ 2069 Err: fmt.Errorf("failed to decode response body, %w", err), 2070 Snapshot: snapshot.Bytes(), 2071 } 2072 return out, metadata, err 2073 } 2074 2075 err = awsRestjson1_deserializeOpDocumentGetSamplingStatisticSummariesOutput(&output, shape) 2076 if err != nil { 2077 var snapshot bytes.Buffer 2078 io.Copy(&snapshot, ringBuffer) 2079 return out, metadata, &smithy.DeserializationError{ 2080 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2081 Snapshot: snapshot.Bytes(), 2082 } 2083 } 2084 2085 return out, metadata, err 2086} 2087 2088func awsRestjson1_deserializeOpErrorGetSamplingStatisticSummaries(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2089 var errorBuffer bytes.Buffer 2090 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2091 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2092 } 2093 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2094 2095 errorCode := "UnknownError" 2096 errorMessage := errorCode 2097 2098 code := response.Header.Get("X-Amzn-ErrorType") 2099 if len(code) != 0 { 2100 errorCode = restjson.SanitizeErrorCode(code) 2101 } 2102 2103 var buff [1024]byte 2104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2105 2106 body := io.TeeReader(errorBody, ringBuffer) 2107 decoder := json.NewDecoder(body) 2108 decoder.UseNumber() 2109 code, message, err := restjson.GetErrorInfo(decoder) 2110 if err != nil { 2111 var snapshot bytes.Buffer 2112 io.Copy(&snapshot, ringBuffer) 2113 err = &smithy.DeserializationError{ 2114 Err: fmt.Errorf("failed to decode response body, %w", err), 2115 Snapshot: snapshot.Bytes(), 2116 } 2117 return err 2118 } 2119 2120 errorBody.Seek(0, io.SeekStart) 2121 if len(code) != 0 { 2122 errorCode = restjson.SanitizeErrorCode(code) 2123 } 2124 if len(message) != 0 { 2125 errorMessage = message 2126 } 2127 2128 switch { 2129 case strings.EqualFold("InvalidRequestException", errorCode): 2130 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2131 2132 case strings.EqualFold("ThrottledException", errorCode): 2133 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2134 2135 default: 2136 genericError := &smithy.GenericAPIError{ 2137 Code: errorCode, 2138 Message: errorMessage, 2139 } 2140 return genericError 2141 2142 } 2143} 2144 2145func awsRestjson1_deserializeOpDocumentGetSamplingStatisticSummariesOutput(v **GetSamplingStatisticSummariesOutput, value interface{}) error { 2146 if v == nil { 2147 return fmt.Errorf("unexpected nil of type %T", v) 2148 } 2149 if value == nil { 2150 return nil 2151 } 2152 2153 shape, ok := value.(map[string]interface{}) 2154 if !ok { 2155 return fmt.Errorf("unexpected JSON type %v", value) 2156 } 2157 2158 var sv *GetSamplingStatisticSummariesOutput 2159 if *v == nil { 2160 sv = &GetSamplingStatisticSummariesOutput{} 2161 } else { 2162 sv = *v 2163 } 2164 2165 for key, value := range shape { 2166 switch key { 2167 case "NextToken": 2168 if value != nil { 2169 jtv, ok := value.(string) 2170 if !ok { 2171 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2172 } 2173 sv.NextToken = ptr.String(jtv) 2174 } 2175 2176 case "SamplingStatisticSummaries": 2177 if err := awsRestjson1_deserializeDocumentSamplingStatisticSummaryList(&sv.SamplingStatisticSummaries, value); err != nil { 2178 return err 2179 } 2180 2181 default: 2182 _, _ = key, value 2183 2184 } 2185 } 2186 *v = sv 2187 return nil 2188} 2189 2190type awsRestjson1_deserializeOpGetSamplingTargets struct { 2191} 2192 2193func (*awsRestjson1_deserializeOpGetSamplingTargets) ID() string { 2194 return "OperationDeserializer" 2195} 2196 2197func (m *awsRestjson1_deserializeOpGetSamplingTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2198 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2199) { 2200 out, metadata, err = next.HandleDeserialize(ctx, in) 2201 if err != nil { 2202 return out, metadata, err 2203 } 2204 2205 response, ok := out.RawResponse.(*smithyhttp.Response) 2206 if !ok { 2207 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2208 } 2209 2210 if response.StatusCode < 200 || response.StatusCode >= 300 { 2211 return out, metadata, awsRestjson1_deserializeOpErrorGetSamplingTargets(response, &metadata) 2212 } 2213 output := &GetSamplingTargetsOutput{} 2214 out.Result = output 2215 2216 var buff [1024]byte 2217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2218 2219 body := io.TeeReader(response.Body, ringBuffer) 2220 2221 decoder := json.NewDecoder(body) 2222 decoder.UseNumber() 2223 var shape interface{} 2224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2225 var snapshot bytes.Buffer 2226 io.Copy(&snapshot, ringBuffer) 2227 err = &smithy.DeserializationError{ 2228 Err: fmt.Errorf("failed to decode response body, %w", err), 2229 Snapshot: snapshot.Bytes(), 2230 } 2231 return out, metadata, err 2232 } 2233 2234 err = awsRestjson1_deserializeOpDocumentGetSamplingTargetsOutput(&output, shape) 2235 if err != nil { 2236 var snapshot bytes.Buffer 2237 io.Copy(&snapshot, ringBuffer) 2238 return out, metadata, &smithy.DeserializationError{ 2239 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2240 Snapshot: snapshot.Bytes(), 2241 } 2242 } 2243 2244 return out, metadata, err 2245} 2246 2247func awsRestjson1_deserializeOpErrorGetSamplingTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2248 var errorBuffer bytes.Buffer 2249 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2250 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2251 } 2252 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2253 2254 errorCode := "UnknownError" 2255 errorMessage := errorCode 2256 2257 code := response.Header.Get("X-Amzn-ErrorType") 2258 if len(code) != 0 { 2259 errorCode = restjson.SanitizeErrorCode(code) 2260 } 2261 2262 var buff [1024]byte 2263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2264 2265 body := io.TeeReader(errorBody, ringBuffer) 2266 decoder := json.NewDecoder(body) 2267 decoder.UseNumber() 2268 code, message, err := restjson.GetErrorInfo(decoder) 2269 if err != nil { 2270 var snapshot bytes.Buffer 2271 io.Copy(&snapshot, ringBuffer) 2272 err = &smithy.DeserializationError{ 2273 Err: fmt.Errorf("failed to decode response body, %w", err), 2274 Snapshot: snapshot.Bytes(), 2275 } 2276 return err 2277 } 2278 2279 errorBody.Seek(0, io.SeekStart) 2280 if len(code) != 0 { 2281 errorCode = restjson.SanitizeErrorCode(code) 2282 } 2283 if len(message) != 0 { 2284 errorMessage = message 2285 } 2286 2287 switch { 2288 case strings.EqualFold("InvalidRequestException", errorCode): 2289 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2290 2291 case strings.EqualFold("ThrottledException", errorCode): 2292 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2293 2294 default: 2295 genericError := &smithy.GenericAPIError{ 2296 Code: errorCode, 2297 Message: errorMessage, 2298 } 2299 return genericError 2300 2301 } 2302} 2303 2304func awsRestjson1_deserializeOpDocumentGetSamplingTargetsOutput(v **GetSamplingTargetsOutput, value interface{}) error { 2305 if v == nil { 2306 return fmt.Errorf("unexpected nil of type %T", v) 2307 } 2308 if value == nil { 2309 return nil 2310 } 2311 2312 shape, ok := value.(map[string]interface{}) 2313 if !ok { 2314 return fmt.Errorf("unexpected JSON type %v", value) 2315 } 2316 2317 var sv *GetSamplingTargetsOutput 2318 if *v == nil { 2319 sv = &GetSamplingTargetsOutput{} 2320 } else { 2321 sv = *v 2322 } 2323 2324 for key, value := range shape { 2325 switch key { 2326 case "LastRuleModification": 2327 if value != nil { 2328 jtv, ok := value.(json.Number) 2329 if !ok { 2330 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2331 } 2332 f64, err := jtv.Float64() 2333 if err != nil { 2334 return err 2335 } 2336 sv.LastRuleModification = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2337 } 2338 2339 case "SamplingTargetDocuments": 2340 if err := awsRestjson1_deserializeDocumentSamplingTargetDocumentList(&sv.SamplingTargetDocuments, value); err != nil { 2341 return err 2342 } 2343 2344 case "UnprocessedStatistics": 2345 if err := awsRestjson1_deserializeDocumentUnprocessedStatisticsList(&sv.UnprocessedStatistics, value); err != nil { 2346 return err 2347 } 2348 2349 default: 2350 _, _ = key, value 2351 2352 } 2353 } 2354 *v = sv 2355 return nil 2356} 2357 2358type awsRestjson1_deserializeOpGetServiceGraph struct { 2359} 2360 2361func (*awsRestjson1_deserializeOpGetServiceGraph) ID() string { 2362 return "OperationDeserializer" 2363} 2364 2365func (m *awsRestjson1_deserializeOpGetServiceGraph) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2366 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2367) { 2368 out, metadata, err = next.HandleDeserialize(ctx, in) 2369 if err != nil { 2370 return out, metadata, err 2371 } 2372 2373 response, ok := out.RawResponse.(*smithyhttp.Response) 2374 if !ok { 2375 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2376 } 2377 2378 if response.StatusCode < 200 || response.StatusCode >= 300 { 2379 return out, metadata, awsRestjson1_deserializeOpErrorGetServiceGraph(response, &metadata) 2380 } 2381 output := &GetServiceGraphOutput{} 2382 out.Result = output 2383 2384 var buff [1024]byte 2385 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2386 2387 body := io.TeeReader(response.Body, ringBuffer) 2388 2389 decoder := json.NewDecoder(body) 2390 decoder.UseNumber() 2391 var shape interface{} 2392 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2393 var snapshot bytes.Buffer 2394 io.Copy(&snapshot, ringBuffer) 2395 err = &smithy.DeserializationError{ 2396 Err: fmt.Errorf("failed to decode response body, %w", err), 2397 Snapshot: snapshot.Bytes(), 2398 } 2399 return out, metadata, err 2400 } 2401 2402 err = awsRestjson1_deserializeOpDocumentGetServiceGraphOutput(&output, shape) 2403 if err != nil { 2404 var snapshot bytes.Buffer 2405 io.Copy(&snapshot, ringBuffer) 2406 return out, metadata, &smithy.DeserializationError{ 2407 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2408 Snapshot: snapshot.Bytes(), 2409 } 2410 } 2411 2412 return out, metadata, err 2413} 2414 2415func awsRestjson1_deserializeOpErrorGetServiceGraph(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2416 var errorBuffer bytes.Buffer 2417 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2418 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2419 } 2420 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2421 2422 errorCode := "UnknownError" 2423 errorMessage := errorCode 2424 2425 code := response.Header.Get("X-Amzn-ErrorType") 2426 if len(code) != 0 { 2427 errorCode = restjson.SanitizeErrorCode(code) 2428 } 2429 2430 var buff [1024]byte 2431 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2432 2433 body := io.TeeReader(errorBody, ringBuffer) 2434 decoder := json.NewDecoder(body) 2435 decoder.UseNumber() 2436 code, message, err := restjson.GetErrorInfo(decoder) 2437 if err != nil { 2438 var snapshot bytes.Buffer 2439 io.Copy(&snapshot, ringBuffer) 2440 err = &smithy.DeserializationError{ 2441 Err: fmt.Errorf("failed to decode response body, %w", err), 2442 Snapshot: snapshot.Bytes(), 2443 } 2444 return err 2445 } 2446 2447 errorBody.Seek(0, io.SeekStart) 2448 if len(code) != 0 { 2449 errorCode = restjson.SanitizeErrorCode(code) 2450 } 2451 if len(message) != 0 { 2452 errorMessage = message 2453 } 2454 2455 switch { 2456 case strings.EqualFold("InvalidRequestException", errorCode): 2457 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2458 2459 case strings.EqualFold("ThrottledException", errorCode): 2460 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2461 2462 default: 2463 genericError := &smithy.GenericAPIError{ 2464 Code: errorCode, 2465 Message: errorMessage, 2466 } 2467 return genericError 2468 2469 } 2470} 2471 2472func awsRestjson1_deserializeOpDocumentGetServiceGraphOutput(v **GetServiceGraphOutput, value interface{}) error { 2473 if v == nil { 2474 return fmt.Errorf("unexpected nil of type %T", v) 2475 } 2476 if value == nil { 2477 return nil 2478 } 2479 2480 shape, ok := value.(map[string]interface{}) 2481 if !ok { 2482 return fmt.Errorf("unexpected JSON type %v", value) 2483 } 2484 2485 var sv *GetServiceGraphOutput 2486 if *v == nil { 2487 sv = &GetServiceGraphOutput{} 2488 } else { 2489 sv = *v 2490 } 2491 2492 for key, value := range shape { 2493 switch key { 2494 case "ContainsOldGroupVersions": 2495 if value != nil { 2496 jtv, ok := value.(bool) 2497 if !ok { 2498 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 2499 } 2500 sv.ContainsOldGroupVersions = jtv 2501 } 2502 2503 case "EndTime": 2504 if value != nil { 2505 jtv, ok := value.(json.Number) 2506 if !ok { 2507 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2508 } 2509 f64, err := jtv.Float64() 2510 if err != nil { 2511 return err 2512 } 2513 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2514 } 2515 2516 case "NextToken": 2517 if value != nil { 2518 jtv, ok := value.(string) 2519 if !ok { 2520 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2521 } 2522 sv.NextToken = ptr.String(jtv) 2523 } 2524 2525 case "Services": 2526 if err := awsRestjson1_deserializeDocumentServiceList(&sv.Services, value); err != nil { 2527 return err 2528 } 2529 2530 case "StartTime": 2531 if value != nil { 2532 jtv, ok := value.(json.Number) 2533 if !ok { 2534 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2535 } 2536 f64, err := jtv.Float64() 2537 if err != nil { 2538 return err 2539 } 2540 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2541 } 2542 2543 default: 2544 _, _ = key, value 2545 2546 } 2547 } 2548 *v = sv 2549 return nil 2550} 2551 2552type awsRestjson1_deserializeOpGetTimeSeriesServiceStatistics struct { 2553} 2554 2555func (*awsRestjson1_deserializeOpGetTimeSeriesServiceStatistics) ID() string { 2556 return "OperationDeserializer" 2557} 2558 2559func (m *awsRestjson1_deserializeOpGetTimeSeriesServiceStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2560 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2561) { 2562 out, metadata, err = next.HandleDeserialize(ctx, in) 2563 if err != nil { 2564 return out, metadata, err 2565 } 2566 2567 response, ok := out.RawResponse.(*smithyhttp.Response) 2568 if !ok { 2569 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2570 } 2571 2572 if response.StatusCode < 200 || response.StatusCode >= 300 { 2573 return out, metadata, awsRestjson1_deserializeOpErrorGetTimeSeriesServiceStatistics(response, &metadata) 2574 } 2575 output := &GetTimeSeriesServiceStatisticsOutput{} 2576 out.Result = output 2577 2578 var buff [1024]byte 2579 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2580 2581 body := io.TeeReader(response.Body, ringBuffer) 2582 2583 decoder := json.NewDecoder(body) 2584 decoder.UseNumber() 2585 var shape interface{} 2586 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2587 var snapshot bytes.Buffer 2588 io.Copy(&snapshot, ringBuffer) 2589 err = &smithy.DeserializationError{ 2590 Err: fmt.Errorf("failed to decode response body, %w", err), 2591 Snapshot: snapshot.Bytes(), 2592 } 2593 return out, metadata, err 2594 } 2595 2596 err = awsRestjson1_deserializeOpDocumentGetTimeSeriesServiceStatisticsOutput(&output, shape) 2597 if err != nil { 2598 var snapshot bytes.Buffer 2599 io.Copy(&snapshot, ringBuffer) 2600 return out, metadata, &smithy.DeserializationError{ 2601 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2602 Snapshot: snapshot.Bytes(), 2603 } 2604 } 2605 2606 return out, metadata, err 2607} 2608 2609func awsRestjson1_deserializeOpErrorGetTimeSeriesServiceStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2610 var errorBuffer bytes.Buffer 2611 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2612 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2613 } 2614 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2615 2616 errorCode := "UnknownError" 2617 errorMessage := errorCode 2618 2619 code := response.Header.Get("X-Amzn-ErrorType") 2620 if len(code) != 0 { 2621 errorCode = restjson.SanitizeErrorCode(code) 2622 } 2623 2624 var buff [1024]byte 2625 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2626 2627 body := io.TeeReader(errorBody, ringBuffer) 2628 decoder := json.NewDecoder(body) 2629 decoder.UseNumber() 2630 code, message, err := restjson.GetErrorInfo(decoder) 2631 if err != nil { 2632 var snapshot bytes.Buffer 2633 io.Copy(&snapshot, ringBuffer) 2634 err = &smithy.DeserializationError{ 2635 Err: fmt.Errorf("failed to decode response body, %w", err), 2636 Snapshot: snapshot.Bytes(), 2637 } 2638 return err 2639 } 2640 2641 errorBody.Seek(0, io.SeekStart) 2642 if len(code) != 0 { 2643 errorCode = restjson.SanitizeErrorCode(code) 2644 } 2645 if len(message) != 0 { 2646 errorMessage = message 2647 } 2648 2649 switch { 2650 case strings.EqualFold("InvalidRequestException", errorCode): 2651 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2652 2653 case strings.EqualFold("ThrottledException", errorCode): 2654 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2655 2656 default: 2657 genericError := &smithy.GenericAPIError{ 2658 Code: errorCode, 2659 Message: errorMessage, 2660 } 2661 return genericError 2662 2663 } 2664} 2665 2666func awsRestjson1_deserializeOpDocumentGetTimeSeriesServiceStatisticsOutput(v **GetTimeSeriesServiceStatisticsOutput, value interface{}) error { 2667 if v == nil { 2668 return fmt.Errorf("unexpected nil of type %T", v) 2669 } 2670 if value == nil { 2671 return nil 2672 } 2673 2674 shape, ok := value.(map[string]interface{}) 2675 if !ok { 2676 return fmt.Errorf("unexpected JSON type %v", value) 2677 } 2678 2679 var sv *GetTimeSeriesServiceStatisticsOutput 2680 if *v == nil { 2681 sv = &GetTimeSeriesServiceStatisticsOutput{} 2682 } else { 2683 sv = *v 2684 } 2685 2686 for key, value := range shape { 2687 switch key { 2688 case "ContainsOldGroupVersions": 2689 if value != nil { 2690 jtv, ok := value.(bool) 2691 if !ok { 2692 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 2693 } 2694 sv.ContainsOldGroupVersions = jtv 2695 } 2696 2697 case "NextToken": 2698 if value != nil { 2699 jtv, ok := value.(string) 2700 if !ok { 2701 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2702 } 2703 sv.NextToken = ptr.String(jtv) 2704 } 2705 2706 case "TimeSeriesServiceStatistics": 2707 if err := awsRestjson1_deserializeDocumentTimeSeriesServiceStatisticsList(&sv.TimeSeriesServiceStatistics, value); err != nil { 2708 return err 2709 } 2710 2711 default: 2712 _, _ = key, value 2713 2714 } 2715 } 2716 *v = sv 2717 return nil 2718} 2719 2720type awsRestjson1_deserializeOpGetTraceGraph struct { 2721} 2722 2723func (*awsRestjson1_deserializeOpGetTraceGraph) ID() string { 2724 return "OperationDeserializer" 2725} 2726 2727func (m *awsRestjson1_deserializeOpGetTraceGraph) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2728 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2729) { 2730 out, metadata, err = next.HandleDeserialize(ctx, in) 2731 if err != nil { 2732 return out, metadata, err 2733 } 2734 2735 response, ok := out.RawResponse.(*smithyhttp.Response) 2736 if !ok { 2737 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2738 } 2739 2740 if response.StatusCode < 200 || response.StatusCode >= 300 { 2741 return out, metadata, awsRestjson1_deserializeOpErrorGetTraceGraph(response, &metadata) 2742 } 2743 output := &GetTraceGraphOutput{} 2744 out.Result = output 2745 2746 var buff [1024]byte 2747 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2748 2749 body := io.TeeReader(response.Body, ringBuffer) 2750 2751 decoder := json.NewDecoder(body) 2752 decoder.UseNumber() 2753 var shape interface{} 2754 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2755 var snapshot bytes.Buffer 2756 io.Copy(&snapshot, ringBuffer) 2757 err = &smithy.DeserializationError{ 2758 Err: fmt.Errorf("failed to decode response body, %w", err), 2759 Snapshot: snapshot.Bytes(), 2760 } 2761 return out, metadata, err 2762 } 2763 2764 err = awsRestjson1_deserializeOpDocumentGetTraceGraphOutput(&output, shape) 2765 if err != nil { 2766 var snapshot bytes.Buffer 2767 io.Copy(&snapshot, ringBuffer) 2768 return out, metadata, &smithy.DeserializationError{ 2769 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2770 Snapshot: snapshot.Bytes(), 2771 } 2772 } 2773 2774 return out, metadata, err 2775} 2776 2777func awsRestjson1_deserializeOpErrorGetTraceGraph(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2778 var errorBuffer bytes.Buffer 2779 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2780 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2781 } 2782 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2783 2784 errorCode := "UnknownError" 2785 errorMessage := errorCode 2786 2787 code := response.Header.Get("X-Amzn-ErrorType") 2788 if len(code) != 0 { 2789 errorCode = restjson.SanitizeErrorCode(code) 2790 } 2791 2792 var buff [1024]byte 2793 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2794 2795 body := io.TeeReader(errorBody, ringBuffer) 2796 decoder := json.NewDecoder(body) 2797 decoder.UseNumber() 2798 code, message, err := restjson.GetErrorInfo(decoder) 2799 if err != nil { 2800 var snapshot bytes.Buffer 2801 io.Copy(&snapshot, ringBuffer) 2802 err = &smithy.DeserializationError{ 2803 Err: fmt.Errorf("failed to decode response body, %w", err), 2804 Snapshot: snapshot.Bytes(), 2805 } 2806 return err 2807 } 2808 2809 errorBody.Seek(0, io.SeekStart) 2810 if len(code) != 0 { 2811 errorCode = restjson.SanitizeErrorCode(code) 2812 } 2813 if len(message) != 0 { 2814 errorMessage = message 2815 } 2816 2817 switch { 2818 case strings.EqualFold("InvalidRequestException", errorCode): 2819 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2820 2821 case strings.EqualFold("ThrottledException", errorCode): 2822 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2823 2824 default: 2825 genericError := &smithy.GenericAPIError{ 2826 Code: errorCode, 2827 Message: errorMessage, 2828 } 2829 return genericError 2830 2831 } 2832} 2833 2834func awsRestjson1_deserializeOpDocumentGetTraceGraphOutput(v **GetTraceGraphOutput, value interface{}) error { 2835 if v == nil { 2836 return fmt.Errorf("unexpected nil of type %T", v) 2837 } 2838 if value == nil { 2839 return nil 2840 } 2841 2842 shape, ok := value.(map[string]interface{}) 2843 if !ok { 2844 return fmt.Errorf("unexpected JSON type %v", value) 2845 } 2846 2847 var sv *GetTraceGraphOutput 2848 if *v == nil { 2849 sv = &GetTraceGraphOutput{} 2850 } else { 2851 sv = *v 2852 } 2853 2854 for key, value := range shape { 2855 switch key { 2856 case "NextToken": 2857 if value != nil { 2858 jtv, ok := value.(string) 2859 if !ok { 2860 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2861 } 2862 sv.NextToken = ptr.String(jtv) 2863 } 2864 2865 case "Services": 2866 if err := awsRestjson1_deserializeDocumentServiceList(&sv.Services, value); err != nil { 2867 return err 2868 } 2869 2870 default: 2871 _, _ = key, value 2872 2873 } 2874 } 2875 *v = sv 2876 return nil 2877} 2878 2879type awsRestjson1_deserializeOpGetTraceSummaries struct { 2880} 2881 2882func (*awsRestjson1_deserializeOpGetTraceSummaries) ID() string { 2883 return "OperationDeserializer" 2884} 2885 2886func (m *awsRestjson1_deserializeOpGetTraceSummaries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2887 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2888) { 2889 out, metadata, err = next.HandleDeserialize(ctx, in) 2890 if err != nil { 2891 return out, metadata, err 2892 } 2893 2894 response, ok := out.RawResponse.(*smithyhttp.Response) 2895 if !ok { 2896 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2897 } 2898 2899 if response.StatusCode < 200 || response.StatusCode >= 300 { 2900 return out, metadata, awsRestjson1_deserializeOpErrorGetTraceSummaries(response, &metadata) 2901 } 2902 output := &GetTraceSummariesOutput{} 2903 out.Result = output 2904 2905 var buff [1024]byte 2906 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2907 2908 body := io.TeeReader(response.Body, ringBuffer) 2909 2910 decoder := json.NewDecoder(body) 2911 decoder.UseNumber() 2912 var shape interface{} 2913 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2914 var snapshot bytes.Buffer 2915 io.Copy(&snapshot, ringBuffer) 2916 err = &smithy.DeserializationError{ 2917 Err: fmt.Errorf("failed to decode response body, %w", err), 2918 Snapshot: snapshot.Bytes(), 2919 } 2920 return out, metadata, err 2921 } 2922 2923 err = awsRestjson1_deserializeOpDocumentGetTraceSummariesOutput(&output, shape) 2924 if err != nil { 2925 var snapshot bytes.Buffer 2926 io.Copy(&snapshot, ringBuffer) 2927 return out, metadata, &smithy.DeserializationError{ 2928 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2929 Snapshot: snapshot.Bytes(), 2930 } 2931 } 2932 2933 return out, metadata, err 2934} 2935 2936func awsRestjson1_deserializeOpErrorGetTraceSummaries(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2937 var errorBuffer bytes.Buffer 2938 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2939 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2940 } 2941 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2942 2943 errorCode := "UnknownError" 2944 errorMessage := errorCode 2945 2946 code := response.Header.Get("X-Amzn-ErrorType") 2947 if len(code) != 0 { 2948 errorCode = restjson.SanitizeErrorCode(code) 2949 } 2950 2951 var buff [1024]byte 2952 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2953 2954 body := io.TeeReader(errorBody, ringBuffer) 2955 decoder := json.NewDecoder(body) 2956 decoder.UseNumber() 2957 code, message, err := restjson.GetErrorInfo(decoder) 2958 if err != nil { 2959 var snapshot bytes.Buffer 2960 io.Copy(&snapshot, ringBuffer) 2961 err = &smithy.DeserializationError{ 2962 Err: fmt.Errorf("failed to decode response body, %w", err), 2963 Snapshot: snapshot.Bytes(), 2964 } 2965 return err 2966 } 2967 2968 errorBody.Seek(0, io.SeekStart) 2969 if len(code) != 0 { 2970 errorCode = restjson.SanitizeErrorCode(code) 2971 } 2972 if len(message) != 0 { 2973 errorMessage = message 2974 } 2975 2976 switch { 2977 case strings.EqualFold("InvalidRequestException", errorCode): 2978 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 2979 2980 case strings.EqualFold("ThrottledException", errorCode): 2981 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 2982 2983 default: 2984 genericError := &smithy.GenericAPIError{ 2985 Code: errorCode, 2986 Message: errorMessage, 2987 } 2988 return genericError 2989 2990 } 2991} 2992 2993func awsRestjson1_deserializeOpDocumentGetTraceSummariesOutput(v **GetTraceSummariesOutput, value interface{}) error { 2994 if v == nil { 2995 return fmt.Errorf("unexpected nil of type %T", v) 2996 } 2997 if value == nil { 2998 return nil 2999 } 3000 3001 shape, ok := value.(map[string]interface{}) 3002 if !ok { 3003 return fmt.Errorf("unexpected JSON type %v", value) 3004 } 3005 3006 var sv *GetTraceSummariesOutput 3007 if *v == nil { 3008 sv = &GetTraceSummariesOutput{} 3009 } else { 3010 sv = *v 3011 } 3012 3013 for key, value := range shape { 3014 switch key { 3015 case "ApproximateTime": 3016 if value != nil { 3017 jtv, ok := value.(json.Number) 3018 if !ok { 3019 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 3020 } 3021 f64, err := jtv.Float64() 3022 if err != nil { 3023 return err 3024 } 3025 sv.ApproximateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3026 } 3027 3028 case "NextToken": 3029 if value != nil { 3030 jtv, ok := value.(string) 3031 if !ok { 3032 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3033 } 3034 sv.NextToken = ptr.String(jtv) 3035 } 3036 3037 case "TracesProcessedCount": 3038 if value != nil { 3039 jtv, ok := value.(json.Number) 3040 if !ok { 3041 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 3042 } 3043 i64, err := jtv.Int64() 3044 if err != nil { 3045 return err 3046 } 3047 sv.TracesProcessedCount = ptr.Int64(i64) 3048 } 3049 3050 case "TraceSummaries": 3051 if err := awsRestjson1_deserializeDocumentTraceSummaryList(&sv.TraceSummaries, value); err != nil { 3052 return err 3053 } 3054 3055 default: 3056 _, _ = key, value 3057 3058 } 3059 } 3060 *v = sv 3061 return nil 3062} 3063 3064type awsRestjson1_deserializeOpListTagsForResource struct { 3065} 3066 3067func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 3068 return "OperationDeserializer" 3069} 3070 3071func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3072 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3073) { 3074 out, metadata, err = next.HandleDeserialize(ctx, in) 3075 if err != nil { 3076 return out, metadata, err 3077 } 3078 3079 response, ok := out.RawResponse.(*smithyhttp.Response) 3080 if !ok { 3081 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3082 } 3083 3084 if response.StatusCode < 200 || response.StatusCode >= 300 { 3085 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 3086 } 3087 output := &ListTagsForResourceOutput{} 3088 out.Result = output 3089 3090 var buff [1024]byte 3091 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3092 3093 body := io.TeeReader(response.Body, ringBuffer) 3094 3095 decoder := json.NewDecoder(body) 3096 decoder.UseNumber() 3097 var shape interface{} 3098 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3099 var snapshot bytes.Buffer 3100 io.Copy(&snapshot, ringBuffer) 3101 err = &smithy.DeserializationError{ 3102 Err: fmt.Errorf("failed to decode response body, %w", err), 3103 Snapshot: snapshot.Bytes(), 3104 } 3105 return out, metadata, err 3106 } 3107 3108 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 3109 if err != nil { 3110 var snapshot bytes.Buffer 3111 io.Copy(&snapshot, ringBuffer) 3112 return out, metadata, &smithy.DeserializationError{ 3113 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3114 Snapshot: snapshot.Bytes(), 3115 } 3116 } 3117 3118 return out, metadata, err 3119} 3120 3121func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3122 var errorBuffer bytes.Buffer 3123 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3124 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3125 } 3126 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3127 3128 errorCode := "UnknownError" 3129 errorMessage := errorCode 3130 3131 code := response.Header.Get("X-Amzn-ErrorType") 3132 if len(code) != 0 { 3133 errorCode = restjson.SanitizeErrorCode(code) 3134 } 3135 3136 var buff [1024]byte 3137 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3138 3139 body := io.TeeReader(errorBody, ringBuffer) 3140 decoder := json.NewDecoder(body) 3141 decoder.UseNumber() 3142 code, message, err := restjson.GetErrorInfo(decoder) 3143 if err != nil { 3144 var snapshot bytes.Buffer 3145 io.Copy(&snapshot, ringBuffer) 3146 err = &smithy.DeserializationError{ 3147 Err: fmt.Errorf("failed to decode response body, %w", err), 3148 Snapshot: snapshot.Bytes(), 3149 } 3150 return err 3151 } 3152 3153 errorBody.Seek(0, io.SeekStart) 3154 if len(code) != 0 { 3155 errorCode = restjson.SanitizeErrorCode(code) 3156 } 3157 if len(message) != 0 { 3158 errorMessage = message 3159 } 3160 3161 switch { 3162 case strings.EqualFold("InvalidRequestException", errorCode): 3163 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3164 3165 case strings.EqualFold("ResourceNotFoundException", errorCode): 3166 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3167 3168 case strings.EqualFold("ThrottledException", errorCode): 3169 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3170 3171 default: 3172 genericError := &smithy.GenericAPIError{ 3173 Code: errorCode, 3174 Message: errorMessage, 3175 } 3176 return genericError 3177 3178 } 3179} 3180 3181func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 3182 if v == nil { 3183 return fmt.Errorf("unexpected nil of type %T", v) 3184 } 3185 if value == nil { 3186 return nil 3187 } 3188 3189 shape, ok := value.(map[string]interface{}) 3190 if !ok { 3191 return fmt.Errorf("unexpected JSON type %v", value) 3192 } 3193 3194 var sv *ListTagsForResourceOutput 3195 if *v == nil { 3196 sv = &ListTagsForResourceOutput{} 3197 } else { 3198 sv = *v 3199 } 3200 3201 for key, value := range shape { 3202 switch key { 3203 case "NextToken": 3204 if value != nil { 3205 jtv, ok := value.(string) 3206 if !ok { 3207 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3208 } 3209 sv.NextToken = ptr.String(jtv) 3210 } 3211 3212 case "Tags": 3213 if err := awsRestjson1_deserializeDocumentTagList(&sv.Tags, value); err != nil { 3214 return err 3215 } 3216 3217 default: 3218 _, _ = key, value 3219 3220 } 3221 } 3222 *v = sv 3223 return nil 3224} 3225 3226type awsRestjson1_deserializeOpPutEncryptionConfig struct { 3227} 3228 3229func (*awsRestjson1_deserializeOpPutEncryptionConfig) ID() string { 3230 return "OperationDeserializer" 3231} 3232 3233func (m *awsRestjson1_deserializeOpPutEncryptionConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3234 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3235) { 3236 out, metadata, err = next.HandleDeserialize(ctx, in) 3237 if err != nil { 3238 return out, metadata, err 3239 } 3240 3241 response, ok := out.RawResponse.(*smithyhttp.Response) 3242 if !ok { 3243 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3244 } 3245 3246 if response.StatusCode < 200 || response.StatusCode >= 300 { 3247 return out, metadata, awsRestjson1_deserializeOpErrorPutEncryptionConfig(response, &metadata) 3248 } 3249 output := &PutEncryptionConfigOutput{} 3250 out.Result = output 3251 3252 var buff [1024]byte 3253 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3254 3255 body := io.TeeReader(response.Body, ringBuffer) 3256 3257 decoder := json.NewDecoder(body) 3258 decoder.UseNumber() 3259 var shape interface{} 3260 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3261 var snapshot bytes.Buffer 3262 io.Copy(&snapshot, ringBuffer) 3263 err = &smithy.DeserializationError{ 3264 Err: fmt.Errorf("failed to decode response body, %w", err), 3265 Snapshot: snapshot.Bytes(), 3266 } 3267 return out, metadata, err 3268 } 3269 3270 err = awsRestjson1_deserializeOpDocumentPutEncryptionConfigOutput(&output, shape) 3271 if err != nil { 3272 var snapshot bytes.Buffer 3273 io.Copy(&snapshot, ringBuffer) 3274 return out, metadata, &smithy.DeserializationError{ 3275 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3276 Snapshot: snapshot.Bytes(), 3277 } 3278 } 3279 3280 return out, metadata, err 3281} 3282 3283func awsRestjson1_deserializeOpErrorPutEncryptionConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3284 var errorBuffer bytes.Buffer 3285 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3286 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3287 } 3288 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3289 3290 errorCode := "UnknownError" 3291 errorMessage := errorCode 3292 3293 code := response.Header.Get("X-Amzn-ErrorType") 3294 if len(code) != 0 { 3295 errorCode = restjson.SanitizeErrorCode(code) 3296 } 3297 3298 var buff [1024]byte 3299 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3300 3301 body := io.TeeReader(errorBody, ringBuffer) 3302 decoder := json.NewDecoder(body) 3303 decoder.UseNumber() 3304 code, message, err := restjson.GetErrorInfo(decoder) 3305 if err != nil { 3306 var snapshot bytes.Buffer 3307 io.Copy(&snapshot, ringBuffer) 3308 err = &smithy.DeserializationError{ 3309 Err: fmt.Errorf("failed to decode response body, %w", err), 3310 Snapshot: snapshot.Bytes(), 3311 } 3312 return err 3313 } 3314 3315 errorBody.Seek(0, io.SeekStart) 3316 if len(code) != 0 { 3317 errorCode = restjson.SanitizeErrorCode(code) 3318 } 3319 if len(message) != 0 { 3320 errorMessage = message 3321 } 3322 3323 switch { 3324 case strings.EqualFold("InvalidRequestException", errorCode): 3325 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3326 3327 case strings.EqualFold("ThrottledException", errorCode): 3328 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3329 3330 default: 3331 genericError := &smithy.GenericAPIError{ 3332 Code: errorCode, 3333 Message: errorMessage, 3334 } 3335 return genericError 3336 3337 } 3338} 3339 3340func awsRestjson1_deserializeOpDocumentPutEncryptionConfigOutput(v **PutEncryptionConfigOutput, value interface{}) error { 3341 if v == nil { 3342 return fmt.Errorf("unexpected nil of type %T", v) 3343 } 3344 if value == nil { 3345 return nil 3346 } 3347 3348 shape, ok := value.(map[string]interface{}) 3349 if !ok { 3350 return fmt.Errorf("unexpected JSON type %v", value) 3351 } 3352 3353 var sv *PutEncryptionConfigOutput 3354 if *v == nil { 3355 sv = &PutEncryptionConfigOutput{} 3356 } else { 3357 sv = *v 3358 } 3359 3360 for key, value := range shape { 3361 switch key { 3362 case "EncryptionConfig": 3363 if err := awsRestjson1_deserializeDocumentEncryptionConfig(&sv.EncryptionConfig, value); err != nil { 3364 return err 3365 } 3366 3367 default: 3368 _, _ = key, value 3369 3370 } 3371 } 3372 *v = sv 3373 return nil 3374} 3375 3376type awsRestjson1_deserializeOpPutTelemetryRecords struct { 3377} 3378 3379func (*awsRestjson1_deserializeOpPutTelemetryRecords) ID() string { 3380 return "OperationDeserializer" 3381} 3382 3383func (m *awsRestjson1_deserializeOpPutTelemetryRecords) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3384 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3385) { 3386 out, metadata, err = next.HandleDeserialize(ctx, in) 3387 if err != nil { 3388 return out, metadata, err 3389 } 3390 3391 response, ok := out.RawResponse.(*smithyhttp.Response) 3392 if !ok { 3393 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3394 } 3395 3396 if response.StatusCode < 200 || response.StatusCode >= 300 { 3397 return out, metadata, awsRestjson1_deserializeOpErrorPutTelemetryRecords(response, &metadata) 3398 } 3399 output := &PutTelemetryRecordsOutput{} 3400 out.Result = output 3401 3402 return out, metadata, err 3403} 3404 3405func awsRestjson1_deserializeOpErrorPutTelemetryRecords(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3406 var errorBuffer bytes.Buffer 3407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3409 } 3410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3411 3412 errorCode := "UnknownError" 3413 errorMessage := errorCode 3414 3415 code := response.Header.Get("X-Amzn-ErrorType") 3416 if len(code) != 0 { 3417 errorCode = restjson.SanitizeErrorCode(code) 3418 } 3419 3420 var buff [1024]byte 3421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3422 3423 body := io.TeeReader(errorBody, ringBuffer) 3424 decoder := json.NewDecoder(body) 3425 decoder.UseNumber() 3426 code, message, err := restjson.GetErrorInfo(decoder) 3427 if err != nil { 3428 var snapshot bytes.Buffer 3429 io.Copy(&snapshot, ringBuffer) 3430 err = &smithy.DeserializationError{ 3431 Err: fmt.Errorf("failed to decode response body, %w", err), 3432 Snapshot: snapshot.Bytes(), 3433 } 3434 return err 3435 } 3436 3437 errorBody.Seek(0, io.SeekStart) 3438 if len(code) != 0 { 3439 errorCode = restjson.SanitizeErrorCode(code) 3440 } 3441 if len(message) != 0 { 3442 errorMessage = message 3443 } 3444 3445 switch { 3446 case strings.EqualFold("InvalidRequestException", errorCode): 3447 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3448 3449 case strings.EqualFold("ThrottledException", errorCode): 3450 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3451 3452 default: 3453 genericError := &smithy.GenericAPIError{ 3454 Code: errorCode, 3455 Message: errorMessage, 3456 } 3457 return genericError 3458 3459 } 3460} 3461 3462type awsRestjson1_deserializeOpPutTraceSegments struct { 3463} 3464 3465func (*awsRestjson1_deserializeOpPutTraceSegments) ID() string { 3466 return "OperationDeserializer" 3467} 3468 3469func (m *awsRestjson1_deserializeOpPutTraceSegments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3470 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3471) { 3472 out, metadata, err = next.HandleDeserialize(ctx, in) 3473 if err != nil { 3474 return out, metadata, err 3475 } 3476 3477 response, ok := out.RawResponse.(*smithyhttp.Response) 3478 if !ok { 3479 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3480 } 3481 3482 if response.StatusCode < 200 || response.StatusCode >= 300 { 3483 return out, metadata, awsRestjson1_deserializeOpErrorPutTraceSegments(response, &metadata) 3484 } 3485 output := &PutTraceSegmentsOutput{} 3486 out.Result = output 3487 3488 var buff [1024]byte 3489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3490 3491 body := io.TeeReader(response.Body, ringBuffer) 3492 3493 decoder := json.NewDecoder(body) 3494 decoder.UseNumber() 3495 var shape interface{} 3496 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3497 var snapshot bytes.Buffer 3498 io.Copy(&snapshot, ringBuffer) 3499 err = &smithy.DeserializationError{ 3500 Err: fmt.Errorf("failed to decode response body, %w", err), 3501 Snapshot: snapshot.Bytes(), 3502 } 3503 return out, metadata, err 3504 } 3505 3506 err = awsRestjson1_deserializeOpDocumentPutTraceSegmentsOutput(&output, shape) 3507 if err != nil { 3508 var snapshot bytes.Buffer 3509 io.Copy(&snapshot, ringBuffer) 3510 return out, metadata, &smithy.DeserializationError{ 3511 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3512 Snapshot: snapshot.Bytes(), 3513 } 3514 } 3515 3516 return out, metadata, err 3517} 3518 3519func awsRestjson1_deserializeOpErrorPutTraceSegments(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3520 var errorBuffer bytes.Buffer 3521 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3522 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3523 } 3524 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3525 3526 errorCode := "UnknownError" 3527 errorMessage := errorCode 3528 3529 code := response.Header.Get("X-Amzn-ErrorType") 3530 if len(code) != 0 { 3531 errorCode = restjson.SanitizeErrorCode(code) 3532 } 3533 3534 var buff [1024]byte 3535 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3536 3537 body := io.TeeReader(errorBody, ringBuffer) 3538 decoder := json.NewDecoder(body) 3539 decoder.UseNumber() 3540 code, message, err := restjson.GetErrorInfo(decoder) 3541 if err != nil { 3542 var snapshot bytes.Buffer 3543 io.Copy(&snapshot, ringBuffer) 3544 err = &smithy.DeserializationError{ 3545 Err: fmt.Errorf("failed to decode response body, %w", err), 3546 Snapshot: snapshot.Bytes(), 3547 } 3548 return err 3549 } 3550 3551 errorBody.Seek(0, io.SeekStart) 3552 if len(code) != 0 { 3553 errorCode = restjson.SanitizeErrorCode(code) 3554 } 3555 if len(message) != 0 { 3556 errorMessage = message 3557 } 3558 3559 switch { 3560 case strings.EqualFold("InvalidRequestException", errorCode): 3561 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3562 3563 case strings.EqualFold("ThrottledException", errorCode): 3564 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3565 3566 default: 3567 genericError := &smithy.GenericAPIError{ 3568 Code: errorCode, 3569 Message: errorMessage, 3570 } 3571 return genericError 3572 3573 } 3574} 3575 3576func awsRestjson1_deserializeOpDocumentPutTraceSegmentsOutput(v **PutTraceSegmentsOutput, value interface{}) error { 3577 if v == nil { 3578 return fmt.Errorf("unexpected nil of type %T", v) 3579 } 3580 if value == nil { 3581 return nil 3582 } 3583 3584 shape, ok := value.(map[string]interface{}) 3585 if !ok { 3586 return fmt.Errorf("unexpected JSON type %v", value) 3587 } 3588 3589 var sv *PutTraceSegmentsOutput 3590 if *v == nil { 3591 sv = &PutTraceSegmentsOutput{} 3592 } else { 3593 sv = *v 3594 } 3595 3596 for key, value := range shape { 3597 switch key { 3598 case "UnprocessedTraceSegments": 3599 if err := awsRestjson1_deserializeDocumentUnprocessedTraceSegmentList(&sv.UnprocessedTraceSegments, value); err != nil { 3600 return err 3601 } 3602 3603 default: 3604 _, _ = key, value 3605 3606 } 3607 } 3608 *v = sv 3609 return nil 3610} 3611 3612type awsRestjson1_deserializeOpTagResource struct { 3613} 3614 3615func (*awsRestjson1_deserializeOpTagResource) ID() string { 3616 return "OperationDeserializer" 3617} 3618 3619func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3620 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3621) { 3622 out, metadata, err = next.HandleDeserialize(ctx, in) 3623 if err != nil { 3624 return out, metadata, err 3625 } 3626 3627 response, ok := out.RawResponse.(*smithyhttp.Response) 3628 if !ok { 3629 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3630 } 3631 3632 if response.StatusCode < 200 || response.StatusCode >= 300 { 3633 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 3634 } 3635 output := &TagResourceOutput{} 3636 out.Result = output 3637 3638 return out, metadata, err 3639} 3640 3641func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3642 var errorBuffer bytes.Buffer 3643 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3644 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3645 } 3646 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3647 3648 errorCode := "UnknownError" 3649 errorMessage := errorCode 3650 3651 code := response.Header.Get("X-Amzn-ErrorType") 3652 if len(code) != 0 { 3653 errorCode = restjson.SanitizeErrorCode(code) 3654 } 3655 3656 var buff [1024]byte 3657 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3658 3659 body := io.TeeReader(errorBody, ringBuffer) 3660 decoder := json.NewDecoder(body) 3661 decoder.UseNumber() 3662 code, message, err := restjson.GetErrorInfo(decoder) 3663 if err != nil { 3664 var snapshot bytes.Buffer 3665 io.Copy(&snapshot, ringBuffer) 3666 err = &smithy.DeserializationError{ 3667 Err: fmt.Errorf("failed to decode response body, %w", err), 3668 Snapshot: snapshot.Bytes(), 3669 } 3670 return err 3671 } 3672 3673 errorBody.Seek(0, io.SeekStart) 3674 if len(code) != 0 { 3675 errorCode = restjson.SanitizeErrorCode(code) 3676 } 3677 if len(message) != 0 { 3678 errorMessage = message 3679 } 3680 3681 switch { 3682 case strings.EqualFold("InvalidRequestException", errorCode): 3683 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3684 3685 case strings.EqualFold("ResourceNotFoundException", errorCode): 3686 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3687 3688 case strings.EqualFold("ThrottledException", errorCode): 3689 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3690 3691 case strings.EqualFold("TooManyTagsException", errorCode): 3692 return awsRestjson1_deserializeErrorTooManyTagsException(response, errorBody) 3693 3694 default: 3695 genericError := &smithy.GenericAPIError{ 3696 Code: errorCode, 3697 Message: errorMessage, 3698 } 3699 return genericError 3700 3701 } 3702} 3703 3704type awsRestjson1_deserializeOpUntagResource struct { 3705} 3706 3707func (*awsRestjson1_deserializeOpUntagResource) ID() string { 3708 return "OperationDeserializer" 3709} 3710 3711func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3712 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3713) { 3714 out, metadata, err = next.HandleDeserialize(ctx, in) 3715 if err != nil { 3716 return out, metadata, err 3717 } 3718 3719 response, ok := out.RawResponse.(*smithyhttp.Response) 3720 if !ok { 3721 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3722 } 3723 3724 if response.StatusCode < 200 || response.StatusCode >= 300 { 3725 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 3726 } 3727 output := &UntagResourceOutput{} 3728 out.Result = output 3729 3730 return out, metadata, err 3731} 3732 3733func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3734 var errorBuffer bytes.Buffer 3735 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3736 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3737 } 3738 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3739 3740 errorCode := "UnknownError" 3741 errorMessage := errorCode 3742 3743 code := response.Header.Get("X-Amzn-ErrorType") 3744 if len(code) != 0 { 3745 errorCode = restjson.SanitizeErrorCode(code) 3746 } 3747 3748 var buff [1024]byte 3749 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3750 3751 body := io.TeeReader(errorBody, ringBuffer) 3752 decoder := json.NewDecoder(body) 3753 decoder.UseNumber() 3754 code, message, err := restjson.GetErrorInfo(decoder) 3755 if err != nil { 3756 var snapshot bytes.Buffer 3757 io.Copy(&snapshot, ringBuffer) 3758 err = &smithy.DeserializationError{ 3759 Err: fmt.Errorf("failed to decode response body, %w", err), 3760 Snapshot: snapshot.Bytes(), 3761 } 3762 return err 3763 } 3764 3765 errorBody.Seek(0, io.SeekStart) 3766 if len(code) != 0 { 3767 errorCode = restjson.SanitizeErrorCode(code) 3768 } 3769 if len(message) != 0 { 3770 errorMessage = message 3771 } 3772 3773 switch { 3774 case strings.EqualFold("InvalidRequestException", errorCode): 3775 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3776 3777 case strings.EqualFold("ResourceNotFoundException", errorCode): 3778 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3779 3780 case strings.EqualFold("ThrottledException", errorCode): 3781 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3782 3783 default: 3784 genericError := &smithy.GenericAPIError{ 3785 Code: errorCode, 3786 Message: errorMessage, 3787 } 3788 return genericError 3789 3790 } 3791} 3792 3793type awsRestjson1_deserializeOpUpdateGroup struct { 3794} 3795 3796func (*awsRestjson1_deserializeOpUpdateGroup) ID() string { 3797 return "OperationDeserializer" 3798} 3799 3800func (m *awsRestjson1_deserializeOpUpdateGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3801 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3802) { 3803 out, metadata, err = next.HandleDeserialize(ctx, in) 3804 if err != nil { 3805 return out, metadata, err 3806 } 3807 3808 response, ok := out.RawResponse.(*smithyhttp.Response) 3809 if !ok { 3810 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3811 } 3812 3813 if response.StatusCode < 200 || response.StatusCode >= 300 { 3814 return out, metadata, awsRestjson1_deserializeOpErrorUpdateGroup(response, &metadata) 3815 } 3816 output := &UpdateGroupOutput{} 3817 out.Result = output 3818 3819 var buff [1024]byte 3820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3821 3822 body := io.TeeReader(response.Body, ringBuffer) 3823 3824 decoder := json.NewDecoder(body) 3825 decoder.UseNumber() 3826 var shape interface{} 3827 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3828 var snapshot bytes.Buffer 3829 io.Copy(&snapshot, ringBuffer) 3830 err = &smithy.DeserializationError{ 3831 Err: fmt.Errorf("failed to decode response body, %w", err), 3832 Snapshot: snapshot.Bytes(), 3833 } 3834 return out, metadata, err 3835 } 3836 3837 err = awsRestjson1_deserializeOpDocumentUpdateGroupOutput(&output, shape) 3838 if err != nil { 3839 var snapshot bytes.Buffer 3840 io.Copy(&snapshot, ringBuffer) 3841 return out, metadata, &smithy.DeserializationError{ 3842 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3843 Snapshot: snapshot.Bytes(), 3844 } 3845 } 3846 3847 return out, metadata, err 3848} 3849 3850func awsRestjson1_deserializeOpErrorUpdateGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3851 var errorBuffer bytes.Buffer 3852 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3853 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3854 } 3855 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3856 3857 errorCode := "UnknownError" 3858 errorMessage := errorCode 3859 3860 code := response.Header.Get("X-Amzn-ErrorType") 3861 if len(code) != 0 { 3862 errorCode = restjson.SanitizeErrorCode(code) 3863 } 3864 3865 var buff [1024]byte 3866 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3867 3868 body := io.TeeReader(errorBody, ringBuffer) 3869 decoder := json.NewDecoder(body) 3870 decoder.UseNumber() 3871 code, message, err := restjson.GetErrorInfo(decoder) 3872 if err != nil { 3873 var snapshot bytes.Buffer 3874 io.Copy(&snapshot, ringBuffer) 3875 err = &smithy.DeserializationError{ 3876 Err: fmt.Errorf("failed to decode response body, %w", err), 3877 Snapshot: snapshot.Bytes(), 3878 } 3879 return err 3880 } 3881 3882 errorBody.Seek(0, io.SeekStart) 3883 if len(code) != 0 { 3884 errorCode = restjson.SanitizeErrorCode(code) 3885 } 3886 if len(message) != 0 { 3887 errorMessage = message 3888 } 3889 3890 switch { 3891 case strings.EqualFold("InvalidRequestException", errorCode): 3892 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 3893 3894 case strings.EqualFold("ThrottledException", errorCode): 3895 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 3896 3897 default: 3898 genericError := &smithy.GenericAPIError{ 3899 Code: errorCode, 3900 Message: errorMessage, 3901 } 3902 return genericError 3903 3904 } 3905} 3906 3907func awsRestjson1_deserializeOpDocumentUpdateGroupOutput(v **UpdateGroupOutput, value interface{}) error { 3908 if v == nil { 3909 return fmt.Errorf("unexpected nil of type %T", v) 3910 } 3911 if value == nil { 3912 return nil 3913 } 3914 3915 shape, ok := value.(map[string]interface{}) 3916 if !ok { 3917 return fmt.Errorf("unexpected JSON type %v", value) 3918 } 3919 3920 var sv *UpdateGroupOutput 3921 if *v == nil { 3922 sv = &UpdateGroupOutput{} 3923 } else { 3924 sv = *v 3925 } 3926 3927 for key, value := range shape { 3928 switch key { 3929 case "Group": 3930 if err := awsRestjson1_deserializeDocumentGroup(&sv.Group, value); err != nil { 3931 return err 3932 } 3933 3934 default: 3935 _, _ = key, value 3936 3937 } 3938 } 3939 *v = sv 3940 return nil 3941} 3942 3943type awsRestjson1_deserializeOpUpdateSamplingRule struct { 3944} 3945 3946func (*awsRestjson1_deserializeOpUpdateSamplingRule) ID() string { 3947 return "OperationDeserializer" 3948} 3949 3950func (m *awsRestjson1_deserializeOpUpdateSamplingRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3951 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3952) { 3953 out, metadata, err = next.HandleDeserialize(ctx, in) 3954 if err != nil { 3955 return out, metadata, err 3956 } 3957 3958 response, ok := out.RawResponse.(*smithyhttp.Response) 3959 if !ok { 3960 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3961 } 3962 3963 if response.StatusCode < 200 || response.StatusCode >= 300 { 3964 return out, metadata, awsRestjson1_deserializeOpErrorUpdateSamplingRule(response, &metadata) 3965 } 3966 output := &UpdateSamplingRuleOutput{} 3967 out.Result = output 3968 3969 var buff [1024]byte 3970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3971 3972 body := io.TeeReader(response.Body, ringBuffer) 3973 3974 decoder := json.NewDecoder(body) 3975 decoder.UseNumber() 3976 var shape interface{} 3977 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3978 var snapshot bytes.Buffer 3979 io.Copy(&snapshot, ringBuffer) 3980 err = &smithy.DeserializationError{ 3981 Err: fmt.Errorf("failed to decode response body, %w", err), 3982 Snapshot: snapshot.Bytes(), 3983 } 3984 return out, metadata, err 3985 } 3986 3987 err = awsRestjson1_deserializeOpDocumentUpdateSamplingRuleOutput(&output, shape) 3988 if err != nil { 3989 var snapshot bytes.Buffer 3990 io.Copy(&snapshot, ringBuffer) 3991 return out, metadata, &smithy.DeserializationError{ 3992 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3993 Snapshot: snapshot.Bytes(), 3994 } 3995 } 3996 3997 return out, metadata, err 3998} 3999 4000func awsRestjson1_deserializeOpErrorUpdateSamplingRule(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4001 var errorBuffer bytes.Buffer 4002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4004 } 4005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4006 4007 errorCode := "UnknownError" 4008 errorMessage := errorCode 4009 4010 code := response.Header.Get("X-Amzn-ErrorType") 4011 if len(code) != 0 { 4012 errorCode = restjson.SanitizeErrorCode(code) 4013 } 4014 4015 var buff [1024]byte 4016 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4017 4018 body := io.TeeReader(errorBody, ringBuffer) 4019 decoder := json.NewDecoder(body) 4020 decoder.UseNumber() 4021 code, message, err := restjson.GetErrorInfo(decoder) 4022 if err != nil { 4023 var snapshot bytes.Buffer 4024 io.Copy(&snapshot, ringBuffer) 4025 err = &smithy.DeserializationError{ 4026 Err: fmt.Errorf("failed to decode response body, %w", err), 4027 Snapshot: snapshot.Bytes(), 4028 } 4029 return err 4030 } 4031 4032 errorBody.Seek(0, io.SeekStart) 4033 if len(code) != 0 { 4034 errorCode = restjson.SanitizeErrorCode(code) 4035 } 4036 if len(message) != 0 { 4037 errorMessage = message 4038 } 4039 4040 switch { 4041 case strings.EqualFold("InvalidRequestException", errorCode): 4042 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody) 4043 4044 case strings.EqualFold("ThrottledException", errorCode): 4045 return awsRestjson1_deserializeErrorThrottledException(response, errorBody) 4046 4047 default: 4048 genericError := &smithy.GenericAPIError{ 4049 Code: errorCode, 4050 Message: errorMessage, 4051 } 4052 return genericError 4053 4054 } 4055} 4056 4057func awsRestjson1_deserializeOpDocumentUpdateSamplingRuleOutput(v **UpdateSamplingRuleOutput, value interface{}) error { 4058 if v == nil { 4059 return fmt.Errorf("unexpected nil of type %T", v) 4060 } 4061 if value == nil { 4062 return nil 4063 } 4064 4065 shape, ok := value.(map[string]interface{}) 4066 if !ok { 4067 return fmt.Errorf("unexpected JSON type %v", value) 4068 } 4069 4070 var sv *UpdateSamplingRuleOutput 4071 if *v == nil { 4072 sv = &UpdateSamplingRuleOutput{} 4073 } else { 4074 sv = *v 4075 } 4076 4077 for key, value := range shape { 4078 switch key { 4079 case "SamplingRuleRecord": 4080 if err := awsRestjson1_deserializeDocumentSamplingRuleRecord(&sv.SamplingRuleRecord, value); err != nil { 4081 return err 4082 } 4083 4084 default: 4085 _, _ = key, value 4086 4087 } 4088 } 4089 *v = sv 4090 return nil 4091} 4092 4093func awsRestjson1_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4094 output := &types.InvalidRequestException{} 4095 var buff [1024]byte 4096 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4097 4098 body := io.TeeReader(errorBody, ringBuffer) 4099 decoder := json.NewDecoder(body) 4100 decoder.UseNumber() 4101 var shape interface{} 4102 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4103 var snapshot bytes.Buffer 4104 io.Copy(&snapshot, ringBuffer) 4105 err = &smithy.DeserializationError{ 4106 Err: fmt.Errorf("failed to decode response body, %w", err), 4107 Snapshot: snapshot.Bytes(), 4108 } 4109 return err 4110 } 4111 4112 err := awsRestjson1_deserializeDocumentInvalidRequestException(&output, shape) 4113 4114 if err != nil { 4115 var snapshot bytes.Buffer 4116 io.Copy(&snapshot, ringBuffer) 4117 err = &smithy.DeserializationError{ 4118 Err: fmt.Errorf("failed to decode response body, %w", err), 4119 Snapshot: snapshot.Bytes(), 4120 } 4121 return err 4122 } 4123 4124 errorBody.Seek(0, io.SeekStart) 4125 4126 return output 4127} 4128 4129func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4130 output := &types.ResourceNotFoundException{} 4131 var buff [1024]byte 4132 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4133 4134 body := io.TeeReader(errorBody, ringBuffer) 4135 decoder := json.NewDecoder(body) 4136 decoder.UseNumber() 4137 var shape interface{} 4138 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4139 var snapshot bytes.Buffer 4140 io.Copy(&snapshot, ringBuffer) 4141 err = &smithy.DeserializationError{ 4142 Err: fmt.Errorf("failed to decode response body, %w", err), 4143 Snapshot: snapshot.Bytes(), 4144 } 4145 return err 4146 } 4147 4148 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 4149 4150 if err != nil { 4151 var snapshot bytes.Buffer 4152 io.Copy(&snapshot, ringBuffer) 4153 err = &smithy.DeserializationError{ 4154 Err: fmt.Errorf("failed to decode response body, %w", err), 4155 Snapshot: snapshot.Bytes(), 4156 } 4157 return err 4158 } 4159 4160 errorBody.Seek(0, io.SeekStart) 4161 4162 return output 4163} 4164 4165func awsRestjson1_deserializeErrorRuleLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4166 output := &types.RuleLimitExceededException{} 4167 var buff [1024]byte 4168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4169 4170 body := io.TeeReader(errorBody, ringBuffer) 4171 decoder := json.NewDecoder(body) 4172 decoder.UseNumber() 4173 var shape interface{} 4174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4175 var snapshot bytes.Buffer 4176 io.Copy(&snapshot, ringBuffer) 4177 err = &smithy.DeserializationError{ 4178 Err: fmt.Errorf("failed to decode response body, %w", err), 4179 Snapshot: snapshot.Bytes(), 4180 } 4181 return err 4182 } 4183 4184 err := awsRestjson1_deserializeDocumentRuleLimitExceededException(&output, shape) 4185 4186 if err != nil { 4187 var snapshot bytes.Buffer 4188 io.Copy(&snapshot, ringBuffer) 4189 err = &smithy.DeserializationError{ 4190 Err: fmt.Errorf("failed to decode response body, %w", err), 4191 Snapshot: snapshot.Bytes(), 4192 } 4193 return err 4194 } 4195 4196 errorBody.Seek(0, io.SeekStart) 4197 4198 return output 4199} 4200 4201func awsRestjson1_deserializeErrorThrottledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4202 output := &types.ThrottledException{} 4203 var buff [1024]byte 4204 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4205 4206 body := io.TeeReader(errorBody, ringBuffer) 4207 decoder := json.NewDecoder(body) 4208 decoder.UseNumber() 4209 var shape interface{} 4210 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4211 var snapshot bytes.Buffer 4212 io.Copy(&snapshot, ringBuffer) 4213 err = &smithy.DeserializationError{ 4214 Err: fmt.Errorf("failed to decode response body, %w", err), 4215 Snapshot: snapshot.Bytes(), 4216 } 4217 return err 4218 } 4219 4220 err := awsRestjson1_deserializeDocumentThrottledException(&output, shape) 4221 4222 if err != nil { 4223 var snapshot bytes.Buffer 4224 io.Copy(&snapshot, ringBuffer) 4225 err = &smithy.DeserializationError{ 4226 Err: fmt.Errorf("failed to decode response body, %w", err), 4227 Snapshot: snapshot.Bytes(), 4228 } 4229 return err 4230 } 4231 4232 errorBody.Seek(0, io.SeekStart) 4233 4234 return output 4235} 4236 4237func awsRestjson1_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4238 output := &types.TooManyTagsException{} 4239 var buff [1024]byte 4240 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4241 4242 body := io.TeeReader(errorBody, ringBuffer) 4243 decoder := json.NewDecoder(body) 4244 decoder.UseNumber() 4245 var shape interface{} 4246 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4247 var snapshot bytes.Buffer 4248 io.Copy(&snapshot, ringBuffer) 4249 err = &smithy.DeserializationError{ 4250 Err: fmt.Errorf("failed to decode response body, %w", err), 4251 Snapshot: snapshot.Bytes(), 4252 } 4253 return err 4254 } 4255 4256 err := awsRestjson1_deserializeDocumentTooManyTagsException(&output, shape) 4257 4258 if err != nil { 4259 var snapshot bytes.Buffer 4260 io.Copy(&snapshot, ringBuffer) 4261 err = &smithy.DeserializationError{ 4262 Err: fmt.Errorf("failed to decode response body, %w", err), 4263 Snapshot: snapshot.Bytes(), 4264 } 4265 return err 4266 } 4267 4268 errorBody.Seek(0, io.SeekStart) 4269 4270 return output 4271} 4272 4273func awsRestjson1_deserializeDocumentAlias(v **types.Alias, value interface{}) error { 4274 if v == nil { 4275 return fmt.Errorf("unexpected nil of type %T", v) 4276 } 4277 if value == nil { 4278 return nil 4279 } 4280 4281 shape, ok := value.(map[string]interface{}) 4282 if !ok { 4283 return fmt.Errorf("unexpected JSON type %v", value) 4284 } 4285 4286 var sv *types.Alias 4287 if *v == nil { 4288 sv = &types.Alias{} 4289 } else { 4290 sv = *v 4291 } 4292 4293 for key, value := range shape { 4294 switch key { 4295 case "Name": 4296 if value != nil { 4297 jtv, ok := value.(string) 4298 if !ok { 4299 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4300 } 4301 sv.Name = ptr.String(jtv) 4302 } 4303 4304 case "Names": 4305 if err := awsRestjson1_deserializeDocumentAliasNames(&sv.Names, value); err != nil { 4306 return err 4307 } 4308 4309 case "Type": 4310 if value != nil { 4311 jtv, ok := value.(string) 4312 if !ok { 4313 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4314 } 4315 sv.Type = ptr.String(jtv) 4316 } 4317 4318 default: 4319 _, _ = key, value 4320 4321 } 4322 } 4323 *v = sv 4324 return nil 4325} 4326 4327func awsRestjson1_deserializeDocumentAliasList(v *[]types.Alias, value interface{}) error { 4328 if v == nil { 4329 return fmt.Errorf("unexpected nil of type %T", v) 4330 } 4331 if value == nil { 4332 return nil 4333 } 4334 4335 shape, ok := value.([]interface{}) 4336 if !ok { 4337 return fmt.Errorf("unexpected JSON type %v", value) 4338 } 4339 4340 var cv []types.Alias 4341 if *v == nil { 4342 cv = []types.Alias{} 4343 } else { 4344 cv = *v 4345 } 4346 4347 for _, value := range shape { 4348 var col types.Alias 4349 destAddr := &col 4350 if err := awsRestjson1_deserializeDocumentAlias(&destAddr, value); err != nil { 4351 return err 4352 } 4353 col = *destAddr 4354 cv = append(cv, col) 4355 4356 } 4357 *v = cv 4358 return nil 4359} 4360 4361func awsRestjson1_deserializeDocumentAliasNames(v *[]string, value interface{}) error { 4362 if v == nil { 4363 return fmt.Errorf("unexpected nil of type %T", v) 4364 } 4365 if value == nil { 4366 return nil 4367 } 4368 4369 shape, ok := value.([]interface{}) 4370 if !ok { 4371 return fmt.Errorf("unexpected JSON type %v", value) 4372 } 4373 4374 var cv []string 4375 if *v == nil { 4376 cv = []string{} 4377 } else { 4378 cv = *v 4379 } 4380 4381 for _, value := range shape { 4382 var col string 4383 if value != nil { 4384 jtv, ok := value.(string) 4385 if !ok { 4386 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4387 } 4388 col = jtv 4389 } 4390 cv = append(cv, col) 4391 4392 } 4393 *v = cv 4394 return nil 4395} 4396 4397func awsRestjson1_deserializeDocumentAnnotations(v *map[string][]types.ValueWithServiceIds, value interface{}) error { 4398 if v == nil { 4399 return fmt.Errorf("unexpected nil of type %T", v) 4400 } 4401 if value == nil { 4402 return nil 4403 } 4404 4405 shape, ok := value.(map[string]interface{}) 4406 if !ok { 4407 return fmt.Errorf("unexpected JSON type %v", value) 4408 } 4409 4410 var mv map[string][]types.ValueWithServiceIds 4411 if *v == nil { 4412 mv = map[string][]types.ValueWithServiceIds{} 4413 } else { 4414 mv = *v 4415 } 4416 4417 for key, value := range shape { 4418 var parsedVal []types.ValueWithServiceIds 4419 mapVar := parsedVal 4420 if err := awsRestjson1_deserializeDocumentValuesWithServiceIds(&mapVar, value); err != nil { 4421 return err 4422 } 4423 parsedVal = mapVar 4424 mv[key] = parsedVal 4425 4426 } 4427 *v = mv 4428 return nil 4429} 4430 4431func awsRestjson1_deserializeDocumentAnnotationValue(v *types.AnnotationValue, value interface{}) error { 4432 if v == nil { 4433 return fmt.Errorf("unexpected nil of type %T", v) 4434 } 4435 if value == nil { 4436 return nil 4437 } 4438 4439 shape, ok := value.(map[string]interface{}) 4440 if !ok { 4441 return fmt.Errorf("unexpected JSON type %v", value) 4442 } 4443 4444 var uv types.AnnotationValue 4445loop: 4446 for key, value := range shape { 4447 switch key { 4448 case "BooleanValue": 4449 var mv bool 4450 if value != nil { 4451 jtv, ok := value.(bool) 4452 if !ok { 4453 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 4454 } 4455 mv = jtv 4456 } 4457 uv = &types.AnnotationValueMemberBooleanValue{Value: mv} 4458 break loop 4459 4460 case "NumberValue": 4461 var mv float64 4462 if value != nil { 4463 jtv, ok := value.(json.Number) 4464 if !ok { 4465 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 4466 } 4467 f64, err := jtv.Float64() 4468 if err != nil { 4469 return err 4470 } 4471 mv = f64 4472 } 4473 uv = &types.AnnotationValueMemberNumberValue{Value: mv} 4474 break loop 4475 4476 case "StringValue": 4477 var mv string 4478 if value != nil { 4479 jtv, ok := value.(string) 4480 if !ok { 4481 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4482 } 4483 mv = jtv 4484 } 4485 uv = &types.AnnotationValueMemberStringValue{Value: mv} 4486 break loop 4487 4488 default: 4489 uv = &types.UnknownUnionMember{Tag: key} 4490 break loop 4491 4492 } 4493 } 4494 *v = uv 4495 return nil 4496} 4497 4498func awsRestjson1_deserializeDocumentAnomalousService(v **types.AnomalousService, value interface{}) error { 4499 if v == nil { 4500 return fmt.Errorf("unexpected nil of type %T", v) 4501 } 4502 if value == nil { 4503 return nil 4504 } 4505 4506 shape, ok := value.(map[string]interface{}) 4507 if !ok { 4508 return fmt.Errorf("unexpected JSON type %v", value) 4509 } 4510 4511 var sv *types.AnomalousService 4512 if *v == nil { 4513 sv = &types.AnomalousService{} 4514 } else { 4515 sv = *v 4516 } 4517 4518 for key, value := range shape { 4519 switch key { 4520 case "ServiceId": 4521 if err := awsRestjson1_deserializeDocumentServiceId(&sv.ServiceId, value); err != nil { 4522 return err 4523 } 4524 4525 default: 4526 _, _ = key, value 4527 4528 } 4529 } 4530 *v = sv 4531 return nil 4532} 4533 4534func awsRestjson1_deserializeDocumentAnomalousServiceList(v *[]types.AnomalousService, value interface{}) error { 4535 if v == nil { 4536 return fmt.Errorf("unexpected nil of type %T", v) 4537 } 4538 if value == nil { 4539 return nil 4540 } 4541 4542 shape, ok := value.([]interface{}) 4543 if !ok { 4544 return fmt.Errorf("unexpected JSON type %v", value) 4545 } 4546 4547 var cv []types.AnomalousService 4548 if *v == nil { 4549 cv = []types.AnomalousService{} 4550 } else { 4551 cv = *v 4552 } 4553 4554 for _, value := range shape { 4555 var col types.AnomalousService 4556 destAddr := &col 4557 if err := awsRestjson1_deserializeDocumentAnomalousService(&destAddr, value); err != nil { 4558 return err 4559 } 4560 col = *destAddr 4561 cv = append(cv, col) 4562 4563 } 4564 *v = cv 4565 return nil 4566} 4567 4568func awsRestjson1_deserializeDocumentAttributeMap(v *map[string]string, value interface{}) error { 4569 if v == nil { 4570 return fmt.Errorf("unexpected nil of type %T", v) 4571 } 4572 if value == nil { 4573 return nil 4574 } 4575 4576 shape, ok := value.(map[string]interface{}) 4577 if !ok { 4578 return fmt.Errorf("unexpected JSON type %v", value) 4579 } 4580 4581 var mv map[string]string 4582 if *v == nil { 4583 mv = map[string]string{} 4584 } else { 4585 mv = *v 4586 } 4587 4588 for key, value := range shape { 4589 var parsedVal string 4590 if value != nil { 4591 jtv, ok := value.(string) 4592 if !ok { 4593 return fmt.Errorf("expected AttributeValue to be of type string, got %T instead", value) 4594 } 4595 parsedVal = jtv 4596 } 4597 mv[key] = parsedVal 4598 4599 } 4600 *v = mv 4601 return nil 4602} 4603 4604func awsRestjson1_deserializeDocumentAvailabilityZoneDetail(v **types.AvailabilityZoneDetail, value interface{}) error { 4605 if v == nil { 4606 return fmt.Errorf("unexpected nil of type %T", v) 4607 } 4608 if value == nil { 4609 return nil 4610 } 4611 4612 shape, ok := value.(map[string]interface{}) 4613 if !ok { 4614 return fmt.Errorf("unexpected JSON type %v", value) 4615 } 4616 4617 var sv *types.AvailabilityZoneDetail 4618 if *v == nil { 4619 sv = &types.AvailabilityZoneDetail{} 4620 } else { 4621 sv = *v 4622 } 4623 4624 for key, value := range shape { 4625 switch key { 4626 case "Name": 4627 if value != nil { 4628 jtv, ok := value.(string) 4629 if !ok { 4630 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4631 } 4632 sv.Name = ptr.String(jtv) 4633 } 4634 4635 default: 4636 _, _ = key, value 4637 4638 } 4639 } 4640 *v = sv 4641 return nil 4642} 4643 4644func awsRestjson1_deserializeDocumentEdge(v **types.Edge, value interface{}) error { 4645 if v == nil { 4646 return fmt.Errorf("unexpected nil of type %T", v) 4647 } 4648 if value == nil { 4649 return nil 4650 } 4651 4652 shape, ok := value.(map[string]interface{}) 4653 if !ok { 4654 return fmt.Errorf("unexpected JSON type %v", value) 4655 } 4656 4657 var sv *types.Edge 4658 if *v == nil { 4659 sv = &types.Edge{} 4660 } else { 4661 sv = *v 4662 } 4663 4664 for key, value := range shape { 4665 switch key { 4666 case "Aliases": 4667 if err := awsRestjson1_deserializeDocumentAliasList(&sv.Aliases, value); err != nil { 4668 return err 4669 } 4670 4671 case "EndTime": 4672 if value != nil { 4673 jtv, ok := value.(json.Number) 4674 if !ok { 4675 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4676 } 4677 f64, err := jtv.Float64() 4678 if err != nil { 4679 return err 4680 } 4681 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4682 } 4683 4684 case "ReferenceId": 4685 if value != nil { 4686 jtv, ok := value.(json.Number) 4687 if !ok { 4688 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 4689 } 4690 i64, err := jtv.Int64() 4691 if err != nil { 4692 return err 4693 } 4694 sv.ReferenceId = ptr.Int32(int32(i64)) 4695 } 4696 4697 case "ResponseTimeHistogram": 4698 if err := awsRestjson1_deserializeDocumentHistogram(&sv.ResponseTimeHistogram, value); err != nil { 4699 return err 4700 } 4701 4702 case "StartTime": 4703 if value != nil { 4704 jtv, ok := value.(json.Number) 4705 if !ok { 4706 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4707 } 4708 f64, err := jtv.Float64() 4709 if err != nil { 4710 return err 4711 } 4712 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4713 } 4714 4715 case "SummaryStatistics": 4716 if err := awsRestjson1_deserializeDocumentEdgeStatistics(&sv.SummaryStatistics, value); err != nil { 4717 return err 4718 } 4719 4720 default: 4721 _, _ = key, value 4722 4723 } 4724 } 4725 *v = sv 4726 return nil 4727} 4728 4729func awsRestjson1_deserializeDocumentEdgeList(v *[]types.Edge, value interface{}) error { 4730 if v == nil { 4731 return fmt.Errorf("unexpected nil of type %T", v) 4732 } 4733 if value == nil { 4734 return nil 4735 } 4736 4737 shape, ok := value.([]interface{}) 4738 if !ok { 4739 return fmt.Errorf("unexpected JSON type %v", value) 4740 } 4741 4742 var cv []types.Edge 4743 if *v == nil { 4744 cv = []types.Edge{} 4745 } else { 4746 cv = *v 4747 } 4748 4749 for _, value := range shape { 4750 var col types.Edge 4751 destAddr := &col 4752 if err := awsRestjson1_deserializeDocumentEdge(&destAddr, value); err != nil { 4753 return err 4754 } 4755 col = *destAddr 4756 cv = append(cv, col) 4757 4758 } 4759 *v = cv 4760 return nil 4761} 4762 4763func awsRestjson1_deserializeDocumentEdgeStatistics(v **types.EdgeStatistics, value interface{}) error { 4764 if v == nil { 4765 return fmt.Errorf("unexpected nil of type %T", v) 4766 } 4767 if value == nil { 4768 return nil 4769 } 4770 4771 shape, ok := value.(map[string]interface{}) 4772 if !ok { 4773 return fmt.Errorf("unexpected JSON type %v", value) 4774 } 4775 4776 var sv *types.EdgeStatistics 4777 if *v == nil { 4778 sv = &types.EdgeStatistics{} 4779 } else { 4780 sv = *v 4781 } 4782 4783 for key, value := range shape { 4784 switch key { 4785 case "ErrorStatistics": 4786 if err := awsRestjson1_deserializeDocumentErrorStatistics(&sv.ErrorStatistics, value); err != nil { 4787 return err 4788 } 4789 4790 case "FaultStatistics": 4791 if err := awsRestjson1_deserializeDocumentFaultStatistics(&sv.FaultStatistics, value); err != nil { 4792 return err 4793 } 4794 4795 case "OkCount": 4796 if value != nil { 4797 jtv, ok := value.(json.Number) 4798 if !ok { 4799 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 4800 } 4801 i64, err := jtv.Int64() 4802 if err != nil { 4803 return err 4804 } 4805 sv.OkCount = ptr.Int64(i64) 4806 } 4807 4808 case "TotalCount": 4809 if value != nil { 4810 jtv, ok := value.(json.Number) 4811 if !ok { 4812 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 4813 } 4814 i64, err := jtv.Int64() 4815 if err != nil { 4816 return err 4817 } 4818 sv.TotalCount = ptr.Int64(i64) 4819 } 4820 4821 case "TotalResponseTime": 4822 if value != nil { 4823 jtv, ok := value.(json.Number) 4824 if !ok { 4825 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 4826 } 4827 f64, err := jtv.Float64() 4828 if err != nil { 4829 return err 4830 } 4831 sv.TotalResponseTime = ptr.Float64(f64) 4832 } 4833 4834 default: 4835 _, _ = key, value 4836 4837 } 4838 } 4839 *v = sv 4840 return nil 4841} 4842 4843func awsRestjson1_deserializeDocumentEncryptionConfig(v **types.EncryptionConfig, value interface{}) error { 4844 if v == nil { 4845 return fmt.Errorf("unexpected nil of type %T", v) 4846 } 4847 if value == nil { 4848 return nil 4849 } 4850 4851 shape, ok := value.(map[string]interface{}) 4852 if !ok { 4853 return fmt.Errorf("unexpected JSON type %v", value) 4854 } 4855 4856 var sv *types.EncryptionConfig 4857 if *v == nil { 4858 sv = &types.EncryptionConfig{} 4859 } else { 4860 sv = *v 4861 } 4862 4863 for key, value := range shape { 4864 switch key { 4865 case "KeyId": 4866 if value != nil { 4867 jtv, ok := value.(string) 4868 if !ok { 4869 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4870 } 4871 sv.KeyId = ptr.String(jtv) 4872 } 4873 4874 case "Status": 4875 if value != nil { 4876 jtv, ok := value.(string) 4877 if !ok { 4878 return fmt.Errorf("expected EncryptionStatus to be of type string, got %T instead", value) 4879 } 4880 sv.Status = types.EncryptionStatus(jtv) 4881 } 4882 4883 case "Type": 4884 if value != nil { 4885 jtv, ok := value.(string) 4886 if !ok { 4887 return fmt.Errorf("expected EncryptionType to be of type string, got %T instead", value) 4888 } 4889 sv.Type = types.EncryptionType(jtv) 4890 } 4891 4892 default: 4893 _, _ = key, value 4894 4895 } 4896 } 4897 *v = sv 4898 return nil 4899} 4900 4901func awsRestjson1_deserializeDocumentErrorRootCause(v **types.ErrorRootCause, value interface{}) error { 4902 if v == nil { 4903 return fmt.Errorf("unexpected nil of type %T", v) 4904 } 4905 if value == nil { 4906 return nil 4907 } 4908 4909 shape, ok := value.(map[string]interface{}) 4910 if !ok { 4911 return fmt.Errorf("unexpected JSON type %v", value) 4912 } 4913 4914 var sv *types.ErrorRootCause 4915 if *v == nil { 4916 sv = &types.ErrorRootCause{} 4917 } else { 4918 sv = *v 4919 } 4920 4921 for key, value := range shape { 4922 switch key { 4923 case "ClientImpacting": 4924 if value != nil { 4925 jtv, ok := value.(bool) 4926 if !ok { 4927 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 4928 } 4929 sv.ClientImpacting = ptr.Bool(jtv) 4930 } 4931 4932 case "Services": 4933 if err := awsRestjson1_deserializeDocumentErrorRootCauseServices(&sv.Services, value); err != nil { 4934 return err 4935 } 4936 4937 default: 4938 _, _ = key, value 4939 4940 } 4941 } 4942 *v = sv 4943 return nil 4944} 4945 4946func awsRestjson1_deserializeDocumentErrorRootCauseEntity(v **types.ErrorRootCauseEntity, value interface{}) error { 4947 if v == nil { 4948 return fmt.Errorf("unexpected nil of type %T", v) 4949 } 4950 if value == nil { 4951 return nil 4952 } 4953 4954 shape, ok := value.(map[string]interface{}) 4955 if !ok { 4956 return fmt.Errorf("unexpected JSON type %v", value) 4957 } 4958 4959 var sv *types.ErrorRootCauseEntity 4960 if *v == nil { 4961 sv = &types.ErrorRootCauseEntity{} 4962 } else { 4963 sv = *v 4964 } 4965 4966 for key, value := range shape { 4967 switch key { 4968 case "Exceptions": 4969 if err := awsRestjson1_deserializeDocumentRootCauseExceptions(&sv.Exceptions, value); err != nil { 4970 return err 4971 } 4972 4973 case "Name": 4974 if value != nil { 4975 jtv, ok := value.(string) 4976 if !ok { 4977 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4978 } 4979 sv.Name = ptr.String(jtv) 4980 } 4981 4982 case "Remote": 4983 if value != nil { 4984 jtv, ok := value.(bool) 4985 if !ok { 4986 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 4987 } 4988 sv.Remote = ptr.Bool(jtv) 4989 } 4990 4991 default: 4992 _, _ = key, value 4993 4994 } 4995 } 4996 *v = sv 4997 return nil 4998} 4999 5000func awsRestjson1_deserializeDocumentErrorRootCauseEntityPath(v *[]types.ErrorRootCauseEntity, value interface{}) error { 5001 if v == nil { 5002 return fmt.Errorf("unexpected nil of type %T", v) 5003 } 5004 if value == nil { 5005 return nil 5006 } 5007 5008 shape, ok := value.([]interface{}) 5009 if !ok { 5010 return fmt.Errorf("unexpected JSON type %v", value) 5011 } 5012 5013 var cv []types.ErrorRootCauseEntity 5014 if *v == nil { 5015 cv = []types.ErrorRootCauseEntity{} 5016 } else { 5017 cv = *v 5018 } 5019 5020 for _, value := range shape { 5021 var col types.ErrorRootCauseEntity 5022 destAddr := &col 5023 if err := awsRestjson1_deserializeDocumentErrorRootCauseEntity(&destAddr, value); err != nil { 5024 return err 5025 } 5026 col = *destAddr 5027 cv = append(cv, col) 5028 5029 } 5030 *v = cv 5031 return nil 5032} 5033 5034func awsRestjson1_deserializeDocumentErrorRootCauses(v *[]types.ErrorRootCause, value interface{}) error { 5035 if v == nil { 5036 return fmt.Errorf("unexpected nil of type %T", v) 5037 } 5038 if value == nil { 5039 return nil 5040 } 5041 5042 shape, ok := value.([]interface{}) 5043 if !ok { 5044 return fmt.Errorf("unexpected JSON type %v", value) 5045 } 5046 5047 var cv []types.ErrorRootCause 5048 if *v == nil { 5049 cv = []types.ErrorRootCause{} 5050 } else { 5051 cv = *v 5052 } 5053 5054 for _, value := range shape { 5055 var col types.ErrorRootCause 5056 destAddr := &col 5057 if err := awsRestjson1_deserializeDocumentErrorRootCause(&destAddr, value); err != nil { 5058 return err 5059 } 5060 col = *destAddr 5061 cv = append(cv, col) 5062 5063 } 5064 *v = cv 5065 return nil 5066} 5067 5068func awsRestjson1_deserializeDocumentErrorRootCauseService(v **types.ErrorRootCauseService, value interface{}) error { 5069 if v == nil { 5070 return fmt.Errorf("unexpected nil of type %T", v) 5071 } 5072 if value == nil { 5073 return nil 5074 } 5075 5076 shape, ok := value.(map[string]interface{}) 5077 if !ok { 5078 return fmt.Errorf("unexpected JSON type %v", value) 5079 } 5080 5081 var sv *types.ErrorRootCauseService 5082 if *v == nil { 5083 sv = &types.ErrorRootCauseService{} 5084 } else { 5085 sv = *v 5086 } 5087 5088 for key, value := range shape { 5089 switch key { 5090 case "AccountId": 5091 if value != nil { 5092 jtv, ok := value.(string) 5093 if !ok { 5094 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5095 } 5096 sv.AccountId = ptr.String(jtv) 5097 } 5098 5099 case "EntityPath": 5100 if err := awsRestjson1_deserializeDocumentErrorRootCauseEntityPath(&sv.EntityPath, value); err != nil { 5101 return err 5102 } 5103 5104 case "Inferred": 5105 if value != nil { 5106 jtv, ok := value.(bool) 5107 if !ok { 5108 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 5109 } 5110 sv.Inferred = ptr.Bool(jtv) 5111 } 5112 5113 case "Name": 5114 if value != nil { 5115 jtv, ok := value.(string) 5116 if !ok { 5117 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5118 } 5119 sv.Name = ptr.String(jtv) 5120 } 5121 5122 case "Names": 5123 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 5124 return err 5125 } 5126 5127 case "Type": 5128 if value != nil { 5129 jtv, ok := value.(string) 5130 if !ok { 5131 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5132 } 5133 sv.Type = ptr.String(jtv) 5134 } 5135 5136 default: 5137 _, _ = key, value 5138 5139 } 5140 } 5141 *v = sv 5142 return nil 5143} 5144 5145func awsRestjson1_deserializeDocumentErrorRootCauseServices(v *[]types.ErrorRootCauseService, value interface{}) error { 5146 if v == nil { 5147 return fmt.Errorf("unexpected nil of type %T", v) 5148 } 5149 if value == nil { 5150 return nil 5151 } 5152 5153 shape, ok := value.([]interface{}) 5154 if !ok { 5155 return fmt.Errorf("unexpected JSON type %v", value) 5156 } 5157 5158 var cv []types.ErrorRootCauseService 5159 if *v == nil { 5160 cv = []types.ErrorRootCauseService{} 5161 } else { 5162 cv = *v 5163 } 5164 5165 for _, value := range shape { 5166 var col types.ErrorRootCauseService 5167 destAddr := &col 5168 if err := awsRestjson1_deserializeDocumentErrorRootCauseService(&destAddr, value); err != nil { 5169 return err 5170 } 5171 col = *destAddr 5172 cv = append(cv, col) 5173 5174 } 5175 *v = cv 5176 return nil 5177} 5178 5179func awsRestjson1_deserializeDocumentErrorStatistics(v **types.ErrorStatistics, value interface{}) error { 5180 if v == nil { 5181 return fmt.Errorf("unexpected nil of type %T", v) 5182 } 5183 if value == nil { 5184 return nil 5185 } 5186 5187 shape, ok := value.(map[string]interface{}) 5188 if !ok { 5189 return fmt.Errorf("unexpected JSON type %v", value) 5190 } 5191 5192 var sv *types.ErrorStatistics 5193 if *v == nil { 5194 sv = &types.ErrorStatistics{} 5195 } else { 5196 sv = *v 5197 } 5198 5199 for key, value := range shape { 5200 switch key { 5201 case "OtherCount": 5202 if value != nil { 5203 jtv, ok := value.(json.Number) 5204 if !ok { 5205 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5206 } 5207 i64, err := jtv.Int64() 5208 if err != nil { 5209 return err 5210 } 5211 sv.OtherCount = ptr.Int64(i64) 5212 } 5213 5214 case "ThrottleCount": 5215 if value != nil { 5216 jtv, ok := value.(json.Number) 5217 if !ok { 5218 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5219 } 5220 i64, err := jtv.Int64() 5221 if err != nil { 5222 return err 5223 } 5224 sv.ThrottleCount = ptr.Int64(i64) 5225 } 5226 5227 case "TotalCount": 5228 if value != nil { 5229 jtv, ok := value.(json.Number) 5230 if !ok { 5231 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5232 } 5233 i64, err := jtv.Int64() 5234 if err != nil { 5235 return err 5236 } 5237 sv.TotalCount = ptr.Int64(i64) 5238 } 5239 5240 default: 5241 _, _ = key, value 5242 5243 } 5244 } 5245 *v = sv 5246 return nil 5247} 5248 5249func awsRestjson1_deserializeDocumentFaultRootCause(v **types.FaultRootCause, value interface{}) error { 5250 if v == nil { 5251 return fmt.Errorf("unexpected nil of type %T", v) 5252 } 5253 if value == nil { 5254 return nil 5255 } 5256 5257 shape, ok := value.(map[string]interface{}) 5258 if !ok { 5259 return fmt.Errorf("unexpected JSON type %v", value) 5260 } 5261 5262 var sv *types.FaultRootCause 5263 if *v == nil { 5264 sv = &types.FaultRootCause{} 5265 } else { 5266 sv = *v 5267 } 5268 5269 for key, value := range shape { 5270 switch key { 5271 case "ClientImpacting": 5272 if value != nil { 5273 jtv, ok := value.(bool) 5274 if !ok { 5275 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 5276 } 5277 sv.ClientImpacting = ptr.Bool(jtv) 5278 } 5279 5280 case "Services": 5281 if err := awsRestjson1_deserializeDocumentFaultRootCauseServices(&sv.Services, value); err != nil { 5282 return err 5283 } 5284 5285 default: 5286 _, _ = key, value 5287 5288 } 5289 } 5290 *v = sv 5291 return nil 5292} 5293 5294func awsRestjson1_deserializeDocumentFaultRootCauseEntity(v **types.FaultRootCauseEntity, value interface{}) error { 5295 if v == nil { 5296 return fmt.Errorf("unexpected nil of type %T", v) 5297 } 5298 if value == nil { 5299 return nil 5300 } 5301 5302 shape, ok := value.(map[string]interface{}) 5303 if !ok { 5304 return fmt.Errorf("unexpected JSON type %v", value) 5305 } 5306 5307 var sv *types.FaultRootCauseEntity 5308 if *v == nil { 5309 sv = &types.FaultRootCauseEntity{} 5310 } else { 5311 sv = *v 5312 } 5313 5314 for key, value := range shape { 5315 switch key { 5316 case "Exceptions": 5317 if err := awsRestjson1_deserializeDocumentRootCauseExceptions(&sv.Exceptions, value); err != nil { 5318 return err 5319 } 5320 5321 case "Name": 5322 if value != nil { 5323 jtv, ok := value.(string) 5324 if !ok { 5325 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5326 } 5327 sv.Name = ptr.String(jtv) 5328 } 5329 5330 case "Remote": 5331 if value != nil { 5332 jtv, ok := value.(bool) 5333 if !ok { 5334 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 5335 } 5336 sv.Remote = ptr.Bool(jtv) 5337 } 5338 5339 default: 5340 _, _ = key, value 5341 5342 } 5343 } 5344 *v = sv 5345 return nil 5346} 5347 5348func awsRestjson1_deserializeDocumentFaultRootCauseEntityPath(v *[]types.FaultRootCauseEntity, value interface{}) error { 5349 if v == nil { 5350 return fmt.Errorf("unexpected nil of type %T", v) 5351 } 5352 if value == nil { 5353 return nil 5354 } 5355 5356 shape, ok := value.([]interface{}) 5357 if !ok { 5358 return fmt.Errorf("unexpected JSON type %v", value) 5359 } 5360 5361 var cv []types.FaultRootCauseEntity 5362 if *v == nil { 5363 cv = []types.FaultRootCauseEntity{} 5364 } else { 5365 cv = *v 5366 } 5367 5368 for _, value := range shape { 5369 var col types.FaultRootCauseEntity 5370 destAddr := &col 5371 if err := awsRestjson1_deserializeDocumentFaultRootCauseEntity(&destAddr, value); err != nil { 5372 return err 5373 } 5374 col = *destAddr 5375 cv = append(cv, col) 5376 5377 } 5378 *v = cv 5379 return nil 5380} 5381 5382func awsRestjson1_deserializeDocumentFaultRootCauses(v *[]types.FaultRootCause, value interface{}) error { 5383 if v == nil { 5384 return fmt.Errorf("unexpected nil of type %T", v) 5385 } 5386 if value == nil { 5387 return nil 5388 } 5389 5390 shape, ok := value.([]interface{}) 5391 if !ok { 5392 return fmt.Errorf("unexpected JSON type %v", value) 5393 } 5394 5395 var cv []types.FaultRootCause 5396 if *v == nil { 5397 cv = []types.FaultRootCause{} 5398 } else { 5399 cv = *v 5400 } 5401 5402 for _, value := range shape { 5403 var col types.FaultRootCause 5404 destAddr := &col 5405 if err := awsRestjson1_deserializeDocumentFaultRootCause(&destAddr, value); err != nil { 5406 return err 5407 } 5408 col = *destAddr 5409 cv = append(cv, col) 5410 5411 } 5412 *v = cv 5413 return nil 5414} 5415 5416func awsRestjson1_deserializeDocumentFaultRootCauseService(v **types.FaultRootCauseService, value interface{}) error { 5417 if v == nil { 5418 return fmt.Errorf("unexpected nil of type %T", v) 5419 } 5420 if value == nil { 5421 return nil 5422 } 5423 5424 shape, ok := value.(map[string]interface{}) 5425 if !ok { 5426 return fmt.Errorf("unexpected JSON type %v", value) 5427 } 5428 5429 var sv *types.FaultRootCauseService 5430 if *v == nil { 5431 sv = &types.FaultRootCauseService{} 5432 } else { 5433 sv = *v 5434 } 5435 5436 for key, value := range shape { 5437 switch key { 5438 case "AccountId": 5439 if value != nil { 5440 jtv, ok := value.(string) 5441 if !ok { 5442 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5443 } 5444 sv.AccountId = ptr.String(jtv) 5445 } 5446 5447 case "EntityPath": 5448 if err := awsRestjson1_deserializeDocumentFaultRootCauseEntityPath(&sv.EntityPath, value); err != nil { 5449 return err 5450 } 5451 5452 case "Inferred": 5453 if value != nil { 5454 jtv, ok := value.(bool) 5455 if !ok { 5456 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 5457 } 5458 sv.Inferred = ptr.Bool(jtv) 5459 } 5460 5461 case "Name": 5462 if value != nil { 5463 jtv, ok := value.(string) 5464 if !ok { 5465 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5466 } 5467 sv.Name = ptr.String(jtv) 5468 } 5469 5470 case "Names": 5471 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 5472 return err 5473 } 5474 5475 case "Type": 5476 if value != nil { 5477 jtv, ok := value.(string) 5478 if !ok { 5479 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5480 } 5481 sv.Type = ptr.String(jtv) 5482 } 5483 5484 default: 5485 _, _ = key, value 5486 5487 } 5488 } 5489 *v = sv 5490 return nil 5491} 5492 5493func awsRestjson1_deserializeDocumentFaultRootCauseServices(v *[]types.FaultRootCauseService, value interface{}) error { 5494 if v == nil { 5495 return fmt.Errorf("unexpected nil of type %T", v) 5496 } 5497 if value == nil { 5498 return nil 5499 } 5500 5501 shape, ok := value.([]interface{}) 5502 if !ok { 5503 return fmt.Errorf("unexpected JSON type %v", value) 5504 } 5505 5506 var cv []types.FaultRootCauseService 5507 if *v == nil { 5508 cv = []types.FaultRootCauseService{} 5509 } else { 5510 cv = *v 5511 } 5512 5513 for _, value := range shape { 5514 var col types.FaultRootCauseService 5515 destAddr := &col 5516 if err := awsRestjson1_deserializeDocumentFaultRootCauseService(&destAddr, value); err != nil { 5517 return err 5518 } 5519 col = *destAddr 5520 cv = append(cv, col) 5521 5522 } 5523 *v = cv 5524 return nil 5525} 5526 5527func awsRestjson1_deserializeDocumentFaultStatistics(v **types.FaultStatistics, value interface{}) error { 5528 if v == nil { 5529 return fmt.Errorf("unexpected nil of type %T", v) 5530 } 5531 if value == nil { 5532 return nil 5533 } 5534 5535 shape, ok := value.(map[string]interface{}) 5536 if !ok { 5537 return fmt.Errorf("unexpected JSON type %v", value) 5538 } 5539 5540 var sv *types.FaultStatistics 5541 if *v == nil { 5542 sv = &types.FaultStatistics{} 5543 } else { 5544 sv = *v 5545 } 5546 5547 for key, value := range shape { 5548 switch key { 5549 case "OtherCount": 5550 if value != nil { 5551 jtv, ok := value.(json.Number) 5552 if !ok { 5553 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5554 } 5555 i64, err := jtv.Int64() 5556 if err != nil { 5557 return err 5558 } 5559 sv.OtherCount = ptr.Int64(i64) 5560 } 5561 5562 case "TotalCount": 5563 if value != nil { 5564 jtv, ok := value.(json.Number) 5565 if !ok { 5566 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5567 } 5568 i64, err := jtv.Int64() 5569 if err != nil { 5570 return err 5571 } 5572 sv.TotalCount = ptr.Int64(i64) 5573 } 5574 5575 default: 5576 _, _ = key, value 5577 5578 } 5579 } 5580 *v = sv 5581 return nil 5582} 5583 5584func awsRestjson1_deserializeDocumentForecastStatistics(v **types.ForecastStatistics, value interface{}) error { 5585 if v == nil { 5586 return fmt.Errorf("unexpected nil of type %T", v) 5587 } 5588 if value == nil { 5589 return nil 5590 } 5591 5592 shape, ok := value.(map[string]interface{}) 5593 if !ok { 5594 return fmt.Errorf("unexpected JSON type %v", value) 5595 } 5596 5597 var sv *types.ForecastStatistics 5598 if *v == nil { 5599 sv = &types.ForecastStatistics{} 5600 } else { 5601 sv = *v 5602 } 5603 5604 for key, value := range shape { 5605 switch key { 5606 case "FaultCountHigh": 5607 if value != nil { 5608 jtv, ok := value.(json.Number) 5609 if !ok { 5610 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5611 } 5612 i64, err := jtv.Int64() 5613 if err != nil { 5614 return err 5615 } 5616 sv.FaultCountHigh = ptr.Int64(i64) 5617 } 5618 5619 case "FaultCountLow": 5620 if value != nil { 5621 jtv, ok := value.(json.Number) 5622 if !ok { 5623 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 5624 } 5625 i64, err := jtv.Int64() 5626 if err != nil { 5627 return err 5628 } 5629 sv.FaultCountLow = ptr.Int64(i64) 5630 } 5631 5632 default: 5633 _, _ = key, value 5634 5635 } 5636 } 5637 *v = sv 5638 return nil 5639} 5640 5641func awsRestjson1_deserializeDocumentGroup(v **types.Group, value interface{}) error { 5642 if v == nil { 5643 return fmt.Errorf("unexpected nil of type %T", v) 5644 } 5645 if value == nil { 5646 return nil 5647 } 5648 5649 shape, ok := value.(map[string]interface{}) 5650 if !ok { 5651 return fmt.Errorf("unexpected JSON type %v", value) 5652 } 5653 5654 var sv *types.Group 5655 if *v == nil { 5656 sv = &types.Group{} 5657 } else { 5658 sv = *v 5659 } 5660 5661 for key, value := range shape { 5662 switch key { 5663 case "FilterExpression": 5664 if value != nil { 5665 jtv, ok := value.(string) 5666 if !ok { 5667 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5668 } 5669 sv.FilterExpression = ptr.String(jtv) 5670 } 5671 5672 case "GroupARN": 5673 if value != nil { 5674 jtv, ok := value.(string) 5675 if !ok { 5676 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5677 } 5678 sv.GroupARN = ptr.String(jtv) 5679 } 5680 5681 case "GroupName": 5682 if value != nil { 5683 jtv, ok := value.(string) 5684 if !ok { 5685 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5686 } 5687 sv.GroupName = ptr.String(jtv) 5688 } 5689 5690 case "InsightsConfiguration": 5691 if err := awsRestjson1_deserializeDocumentInsightsConfiguration(&sv.InsightsConfiguration, value); err != nil { 5692 return err 5693 } 5694 5695 default: 5696 _, _ = key, value 5697 5698 } 5699 } 5700 *v = sv 5701 return nil 5702} 5703 5704func awsRestjson1_deserializeDocumentGroupSummary(v **types.GroupSummary, value interface{}) error { 5705 if v == nil { 5706 return fmt.Errorf("unexpected nil of type %T", v) 5707 } 5708 if value == nil { 5709 return nil 5710 } 5711 5712 shape, ok := value.(map[string]interface{}) 5713 if !ok { 5714 return fmt.Errorf("unexpected JSON type %v", value) 5715 } 5716 5717 var sv *types.GroupSummary 5718 if *v == nil { 5719 sv = &types.GroupSummary{} 5720 } else { 5721 sv = *v 5722 } 5723 5724 for key, value := range shape { 5725 switch key { 5726 case "FilterExpression": 5727 if value != nil { 5728 jtv, ok := value.(string) 5729 if !ok { 5730 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5731 } 5732 sv.FilterExpression = ptr.String(jtv) 5733 } 5734 5735 case "GroupARN": 5736 if value != nil { 5737 jtv, ok := value.(string) 5738 if !ok { 5739 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5740 } 5741 sv.GroupARN = ptr.String(jtv) 5742 } 5743 5744 case "GroupName": 5745 if value != nil { 5746 jtv, ok := value.(string) 5747 if !ok { 5748 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5749 } 5750 sv.GroupName = ptr.String(jtv) 5751 } 5752 5753 case "InsightsConfiguration": 5754 if err := awsRestjson1_deserializeDocumentInsightsConfiguration(&sv.InsightsConfiguration, value); err != nil { 5755 return err 5756 } 5757 5758 default: 5759 _, _ = key, value 5760 5761 } 5762 } 5763 *v = sv 5764 return nil 5765} 5766 5767func awsRestjson1_deserializeDocumentGroupSummaryList(v *[]types.GroupSummary, value interface{}) error { 5768 if v == nil { 5769 return fmt.Errorf("unexpected nil of type %T", v) 5770 } 5771 if value == nil { 5772 return nil 5773 } 5774 5775 shape, ok := value.([]interface{}) 5776 if !ok { 5777 return fmt.Errorf("unexpected JSON type %v", value) 5778 } 5779 5780 var cv []types.GroupSummary 5781 if *v == nil { 5782 cv = []types.GroupSummary{} 5783 } else { 5784 cv = *v 5785 } 5786 5787 for _, value := range shape { 5788 var col types.GroupSummary 5789 destAddr := &col 5790 if err := awsRestjson1_deserializeDocumentGroupSummary(&destAddr, value); err != nil { 5791 return err 5792 } 5793 col = *destAddr 5794 cv = append(cv, col) 5795 5796 } 5797 *v = cv 5798 return nil 5799} 5800 5801func awsRestjson1_deserializeDocumentHistogram(v *[]types.HistogramEntry, value interface{}) error { 5802 if v == nil { 5803 return fmt.Errorf("unexpected nil of type %T", v) 5804 } 5805 if value == nil { 5806 return nil 5807 } 5808 5809 shape, ok := value.([]interface{}) 5810 if !ok { 5811 return fmt.Errorf("unexpected JSON type %v", value) 5812 } 5813 5814 var cv []types.HistogramEntry 5815 if *v == nil { 5816 cv = []types.HistogramEntry{} 5817 } else { 5818 cv = *v 5819 } 5820 5821 for _, value := range shape { 5822 var col types.HistogramEntry 5823 destAddr := &col 5824 if err := awsRestjson1_deserializeDocumentHistogramEntry(&destAddr, value); err != nil { 5825 return err 5826 } 5827 col = *destAddr 5828 cv = append(cv, col) 5829 5830 } 5831 *v = cv 5832 return nil 5833} 5834 5835func awsRestjson1_deserializeDocumentHistogramEntry(v **types.HistogramEntry, value interface{}) error { 5836 if v == nil { 5837 return fmt.Errorf("unexpected nil of type %T", v) 5838 } 5839 if value == nil { 5840 return nil 5841 } 5842 5843 shape, ok := value.(map[string]interface{}) 5844 if !ok { 5845 return fmt.Errorf("unexpected JSON type %v", value) 5846 } 5847 5848 var sv *types.HistogramEntry 5849 if *v == nil { 5850 sv = &types.HistogramEntry{} 5851 } else { 5852 sv = *v 5853 } 5854 5855 for key, value := range shape { 5856 switch key { 5857 case "Count": 5858 if value != nil { 5859 jtv, ok := value.(json.Number) 5860 if !ok { 5861 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5862 } 5863 i64, err := jtv.Int64() 5864 if err != nil { 5865 return err 5866 } 5867 sv.Count = int32(i64) 5868 } 5869 5870 case "Value": 5871 if value != nil { 5872 jtv, ok := value.(json.Number) 5873 if !ok { 5874 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 5875 } 5876 f64, err := jtv.Float64() 5877 if err != nil { 5878 return err 5879 } 5880 sv.Value = f64 5881 } 5882 5883 default: 5884 _, _ = key, value 5885 5886 } 5887 } 5888 *v = sv 5889 return nil 5890} 5891 5892func awsRestjson1_deserializeDocumentHttp(v **types.Http, value interface{}) error { 5893 if v == nil { 5894 return fmt.Errorf("unexpected nil of type %T", v) 5895 } 5896 if value == nil { 5897 return nil 5898 } 5899 5900 shape, ok := value.(map[string]interface{}) 5901 if !ok { 5902 return fmt.Errorf("unexpected JSON type %v", value) 5903 } 5904 5905 var sv *types.Http 5906 if *v == nil { 5907 sv = &types.Http{} 5908 } else { 5909 sv = *v 5910 } 5911 5912 for key, value := range shape { 5913 switch key { 5914 case "ClientIp": 5915 if value != nil { 5916 jtv, ok := value.(string) 5917 if !ok { 5918 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5919 } 5920 sv.ClientIp = ptr.String(jtv) 5921 } 5922 5923 case "HttpMethod": 5924 if value != nil { 5925 jtv, ok := value.(string) 5926 if !ok { 5927 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5928 } 5929 sv.HttpMethod = ptr.String(jtv) 5930 } 5931 5932 case "HttpStatus": 5933 if value != nil { 5934 jtv, ok := value.(json.Number) 5935 if !ok { 5936 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 5937 } 5938 i64, err := jtv.Int64() 5939 if err != nil { 5940 return err 5941 } 5942 sv.HttpStatus = ptr.Int32(int32(i64)) 5943 } 5944 5945 case "HttpURL": 5946 if value != nil { 5947 jtv, ok := value.(string) 5948 if !ok { 5949 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5950 } 5951 sv.HttpURL = ptr.String(jtv) 5952 } 5953 5954 case "UserAgent": 5955 if value != nil { 5956 jtv, ok := value.(string) 5957 if !ok { 5958 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5959 } 5960 sv.UserAgent = ptr.String(jtv) 5961 } 5962 5963 default: 5964 _, _ = key, value 5965 5966 } 5967 } 5968 *v = sv 5969 return nil 5970} 5971 5972func awsRestjson1_deserializeDocumentInsight(v **types.Insight, value interface{}) error { 5973 if v == nil { 5974 return fmt.Errorf("unexpected nil of type %T", v) 5975 } 5976 if value == nil { 5977 return nil 5978 } 5979 5980 shape, ok := value.(map[string]interface{}) 5981 if !ok { 5982 return fmt.Errorf("unexpected JSON type %v", value) 5983 } 5984 5985 var sv *types.Insight 5986 if *v == nil { 5987 sv = &types.Insight{} 5988 } else { 5989 sv = *v 5990 } 5991 5992 for key, value := range shape { 5993 switch key { 5994 case "Categories": 5995 if err := awsRestjson1_deserializeDocumentInsightCategoryList(&sv.Categories, value); err != nil { 5996 return err 5997 } 5998 5999 case "ClientRequestImpactStatistics": 6000 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.ClientRequestImpactStatistics, value); err != nil { 6001 return err 6002 } 6003 6004 case "EndTime": 6005 if value != nil { 6006 jtv, ok := value.(json.Number) 6007 if !ok { 6008 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6009 } 6010 f64, err := jtv.Float64() 6011 if err != nil { 6012 return err 6013 } 6014 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6015 } 6016 6017 case "GroupARN": 6018 if value != nil { 6019 jtv, ok := value.(string) 6020 if !ok { 6021 return fmt.Errorf("expected GroupARN to be of type string, got %T instead", value) 6022 } 6023 sv.GroupARN = ptr.String(jtv) 6024 } 6025 6026 case "GroupName": 6027 if value != nil { 6028 jtv, ok := value.(string) 6029 if !ok { 6030 return fmt.Errorf("expected GroupName to be of type string, got %T instead", value) 6031 } 6032 sv.GroupName = ptr.String(jtv) 6033 } 6034 6035 case "InsightId": 6036 if value != nil { 6037 jtv, ok := value.(string) 6038 if !ok { 6039 return fmt.Errorf("expected InsightId to be of type string, got %T instead", value) 6040 } 6041 sv.InsightId = ptr.String(jtv) 6042 } 6043 6044 case "RootCauseServiceId": 6045 if err := awsRestjson1_deserializeDocumentServiceId(&sv.RootCauseServiceId, value); err != nil { 6046 return err 6047 } 6048 6049 case "RootCauseServiceRequestImpactStatistics": 6050 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.RootCauseServiceRequestImpactStatistics, value); err != nil { 6051 return err 6052 } 6053 6054 case "StartTime": 6055 if value != nil { 6056 jtv, ok := value.(json.Number) 6057 if !ok { 6058 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6059 } 6060 f64, err := jtv.Float64() 6061 if err != nil { 6062 return err 6063 } 6064 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6065 } 6066 6067 case "State": 6068 if value != nil { 6069 jtv, ok := value.(string) 6070 if !ok { 6071 return fmt.Errorf("expected InsightState to be of type string, got %T instead", value) 6072 } 6073 sv.State = types.InsightState(jtv) 6074 } 6075 6076 case "Summary": 6077 if value != nil { 6078 jtv, ok := value.(string) 6079 if !ok { 6080 return fmt.Errorf("expected InsightSummaryText to be of type string, got %T instead", value) 6081 } 6082 sv.Summary = ptr.String(jtv) 6083 } 6084 6085 case "TopAnomalousServices": 6086 if err := awsRestjson1_deserializeDocumentAnomalousServiceList(&sv.TopAnomalousServices, value); err != nil { 6087 return err 6088 } 6089 6090 default: 6091 _, _ = key, value 6092 6093 } 6094 } 6095 *v = sv 6096 return nil 6097} 6098 6099func awsRestjson1_deserializeDocumentInsightCategoryList(v *[]types.InsightCategory, value interface{}) error { 6100 if v == nil { 6101 return fmt.Errorf("unexpected nil of type %T", v) 6102 } 6103 if value == nil { 6104 return nil 6105 } 6106 6107 shape, ok := value.([]interface{}) 6108 if !ok { 6109 return fmt.Errorf("unexpected JSON type %v", value) 6110 } 6111 6112 var cv []types.InsightCategory 6113 if *v == nil { 6114 cv = []types.InsightCategory{} 6115 } else { 6116 cv = *v 6117 } 6118 6119 for _, value := range shape { 6120 var col types.InsightCategory 6121 if value != nil { 6122 jtv, ok := value.(string) 6123 if !ok { 6124 return fmt.Errorf("expected InsightCategory to be of type string, got %T instead", value) 6125 } 6126 col = types.InsightCategory(jtv) 6127 } 6128 cv = append(cv, col) 6129 6130 } 6131 *v = cv 6132 return nil 6133} 6134 6135func awsRestjson1_deserializeDocumentInsightEvent(v **types.InsightEvent, value interface{}) error { 6136 if v == nil { 6137 return fmt.Errorf("unexpected nil of type %T", v) 6138 } 6139 if value == nil { 6140 return nil 6141 } 6142 6143 shape, ok := value.(map[string]interface{}) 6144 if !ok { 6145 return fmt.Errorf("unexpected JSON type %v", value) 6146 } 6147 6148 var sv *types.InsightEvent 6149 if *v == nil { 6150 sv = &types.InsightEvent{} 6151 } else { 6152 sv = *v 6153 } 6154 6155 for key, value := range shape { 6156 switch key { 6157 case "ClientRequestImpactStatistics": 6158 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.ClientRequestImpactStatistics, value); err != nil { 6159 return err 6160 } 6161 6162 case "EventTime": 6163 if value != nil { 6164 jtv, ok := value.(json.Number) 6165 if !ok { 6166 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6167 } 6168 f64, err := jtv.Float64() 6169 if err != nil { 6170 return err 6171 } 6172 sv.EventTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6173 } 6174 6175 case "RootCauseServiceRequestImpactStatistics": 6176 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.RootCauseServiceRequestImpactStatistics, value); err != nil { 6177 return err 6178 } 6179 6180 case "Summary": 6181 if value != nil { 6182 jtv, ok := value.(string) 6183 if !ok { 6184 return fmt.Errorf("expected EventSummaryText to be of type string, got %T instead", value) 6185 } 6186 sv.Summary = ptr.String(jtv) 6187 } 6188 6189 case "TopAnomalousServices": 6190 if err := awsRestjson1_deserializeDocumentAnomalousServiceList(&sv.TopAnomalousServices, value); err != nil { 6191 return err 6192 } 6193 6194 default: 6195 _, _ = key, value 6196 6197 } 6198 } 6199 *v = sv 6200 return nil 6201} 6202 6203func awsRestjson1_deserializeDocumentInsightEventList(v *[]types.InsightEvent, value interface{}) error { 6204 if v == nil { 6205 return fmt.Errorf("unexpected nil of type %T", v) 6206 } 6207 if value == nil { 6208 return nil 6209 } 6210 6211 shape, ok := value.([]interface{}) 6212 if !ok { 6213 return fmt.Errorf("unexpected JSON type %v", value) 6214 } 6215 6216 var cv []types.InsightEvent 6217 if *v == nil { 6218 cv = []types.InsightEvent{} 6219 } else { 6220 cv = *v 6221 } 6222 6223 for _, value := range shape { 6224 var col types.InsightEvent 6225 destAddr := &col 6226 if err := awsRestjson1_deserializeDocumentInsightEvent(&destAddr, value); err != nil { 6227 return err 6228 } 6229 col = *destAddr 6230 cv = append(cv, col) 6231 6232 } 6233 *v = cv 6234 return nil 6235} 6236 6237func awsRestjson1_deserializeDocumentInsightImpactGraphEdge(v **types.InsightImpactGraphEdge, value interface{}) error { 6238 if v == nil { 6239 return fmt.Errorf("unexpected nil of type %T", v) 6240 } 6241 if value == nil { 6242 return nil 6243 } 6244 6245 shape, ok := value.(map[string]interface{}) 6246 if !ok { 6247 return fmt.Errorf("unexpected JSON type %v", value) 6248 } 6249 6250 var sv *types.InsightImpactGraphEdge 6251 if *v == nil { 6252 sv = &types.InsightImpactGraphEdge{} 6253 } else { 6254 sv = *v 6255 } 6256 6257 for key, value := range shape { 6258 switch key { 6259 case "ReferenceId": 6260 if value != nil { 6261 jtv, ok := value.(json.Number) 6262 if !ok { 6263 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 6264 } 6265 i64, err := jtv.Int64() 6266 if err != nil { 6267 return err 6268 } 6269 sv.ReferenceId = ptr.Int32(int32(i64)) 6270 } 6271 6272 default: 6273 _, _ = key, value 6274 6275 } 6276 } 6277 *v = sv 6278 return nil 6279} 6280 6281func awsRestjson1_deserializeDocumentInsightImpactGraphEdgeList(v *[]types.InsightImpactGraphEdge, value interface{}) error { 6282 if v == nil { 6283 return fmt.Errorf("unexpected nil of type %T", v) 6284 } 6285 if value == nil { 6286 return nil 6287 } 6288 6289 shape, ok := value.([]interface{}) 6290 if !ok { 6291 return fmt.Errorf("unexpected JSON type %v", value) 6292 } 6293 6294 var cv []types.InsightImpactGraphEdge 6295 if *v == nil { 6296 cv = []types.InsightImpactGraphEdge{} 6297 } else { 6298 cv = *v 6299 } 6300 6301 for _, value := range shape { 6302 var col types.InsightImpactGraphEdge 6303 destAddr := &col 6304 if err := awsRestjson1_deserializeDocumentInsightImpactGraphEdge(&destAddr, value); err != nil { 6305 return err 6306 } 6307 col = *destAddr 6308 cv = append(cv, col) 6309 6310 } 6311 *v = cv 6312 return nil 6313} 6314 6315func awsRestjson1_deserializeDocumentInsightImpactGraphService(v **types.InsightImpactGraphService, value interface{}) error { 6316 if v == nil { 6317 return fmt.Errorf("unexpected nil of type %T", v) 6318 } 6319 if value == nil { 6320 return nil 6321 } 6322 6323 shape, ok := value.(map[string]interface{}) 6324 if !ok { 6325 return fmt.Errorf("unexpected JSON type %v", value) 6326 } 6327 6328 var sv *types.InsightImpactGraphService 6329 if *v == nil { 6330 sv = &types.InsightImpactGraphService{} 6331 } else { 6332 sv = *v 6333 } 6334 6335 for key, value := range shape { 6336 switch key { 6337 case "AccountId": 6338 if value != nil { 6339 jtv, ok := value.(string) 6340 if !ok { 6341 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6342 } 6343 sv.AccountId = ptr.String(jtv) 6344 } 6345 6346 case "Edges": 6347 if err := awsRestjson1_deserializeDocumentInsightImpactGraphEdgeList(&sv.Edges, value); err != nil { 6348 return err 6349 } 6350 6351 case "Name": 6352 if value != nil { 6353 jtv, ok := value.(string) 6354 if !ok { 6355 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6356 } 6357 sv.Name = ptr.String(jtv) 6358 } 6359 6360 case "Names": 6361 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 6362 return err 6363 } 6364 6365 case "ReferenceId": 6366 if value != nil { 6367 jtv, ok := value.(json.Number) 6368 if !ok { 6369 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 6370 } 6371 i64, err := jtv.Int64() 6372 if err != nil { 6373 return err 6374 } 6375 sv.ReferenceId = ptr.Int32(int32(i64)) 6376 } 6377 6378 case "Type": 6379 if value != nil { 6380 jtv, ok := value.(string) 6381 if !ok { 6382 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6383 } 6384 sv.Type = ptr.String(jtv) 6385 } 6386 6387 default: 6388 _, _ = key, value 6389 6390 } 6391 } 6392 *v = sv 6393 return nil 6394} 6395 6396func awsRestjson1_deserializeDocumentInsightImpactGraphServiceList(v *[]types.InsightImpactGraphService, value interface{}) error { 6397 if v == nil { 6398 return fmt.Errorf("unexpected nil of type %T", v) 6399 } 6400 if value == nil { 6401 return nil 6402 } 6403 6404 shape, ok := value.([]interface{}) 6405 if !ok { 6406 return fmt.Errorf("unexpected JSON type %v", value) 6407 } 6408 6409 var cv []types.InsightImpactGraphService 6410 if *v == nil { 6411 cv = []types.InsightImpactGraphService{} 6412 } else { 6413 cv = *v 6414 } 6415 6416 for _, value := range shape { 6417 var col types.InsightImpactGraphService 6418 destAddr := &col 6419 if err := awsRestjson1_deserializeDocumentInsightImpactGraphService(&destAddr, value); err != nil { 6420 return err 6421 } 6422 col = *destAddr 6423 cv = append(cv, col) 6424 6425 } 6426 *v = cv 6427 return nil 6428} 6429 6430func awsRestjson1_deserializeDocumentInsightsConfiguration(v **types.InsightsConfiguration, value interface{}) error { 6431 if v == nil { 6432 return fmt.Errorf("unexpected nil of type %T", v) 6433 } 6434 if value == nil { 6435 return nil 6436 } 6437 6438 shape, ok := value.(map[string]interface{}) 6439 if !ok { 6440 return fmt.Errorf("unexpected JSON type %v", value) 6441 } 6442 6443 var sv *types.InsightsConfiguration 6444 if *v == nil { 6445 sv = &types.InsightsConfiguration{} 6446 } else { 6447 sv = *v 6448 } 6449 6450 for key, value := range shape { 6451 switch key { 6452 case "InsightsEnabled": 6453 if value != nil { 6454 jtv, ok := value.(bool) 6455 if !ok { 6456 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 6457 } 6458 sv.InsightsEnabled = ptr.Bool(jtv) 6459 } 6460 6461 case "NotificationsEnabled": 6462 if value != nil { 6463 jtv, ok := value.(bool) 6464 if !ok { 6465 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 6466 } 6467 sv.NotificationsEnabled = ptr.Bool(jtv) 6468 } 6469 6470 default: 6471 _, _ = key, value 6472 6473 } 6474 } 6475 *v = sv 6476 return nil 6477} 6478 6479func awsRestjson1_deserializeDocumentInsightSummary(v **types.InsightSummary, value interface{}) error { 6480 if v == nil { 6481 return fmt.Errorf("unexpected nil of type %T", v) 6482 } 6483 if value == nil { 6484 return nil 6485 } 6486 6487 shape, ok := value.(map[string]interface{}) 6488 if !ok { 6489 return fmt.Errorf("unexpected JSON type %v", value) 6490 } 6491 6492 var sv *types.InsightSummary 6493 if *v == nil { 6494 sv = &types.InsightSummary{} 6495 } else { 6496 sv = *v 6497 } 6498 6499 for key, value := range shape { 6500 switch key { 6501 case "Categories": 6502 if err := awsRestjson1_deserializeDocumentInsightCategoryList(&sv.Categories, value); err != nil { 6503 return err 6504 } 6505 6506 case "ClientRequestImpactStatistics": 6507 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.ClientRequestImpactStatistics, value); err != nil { 6508 return err 6509 } 6510 6511 case "EndTime": 6512 if value != nil { 6513 jtv, ok := value.(json.Number) 6514 if !ok { 6515 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6516 } 6517 f64, err := jtv.Float64() 6518 if err != nil { 6519 return err 6520 } 6521 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6522 } 6523 6524 case "GroupARN": 6525 if value != nil { 6526 jtv, ok := value.(string) 6527 if !ok { 6528 return fmt.Errorf("expected GroupARN to be of type string, got %T instead", value) 6529 } 6530 sv.GroupARN = ptr.String(jtv) 6531 } 6532 6533 case "GroupName": 6534 if value != nil { 6535 jtv, ok := value.(string) 6536 if !ok { 6537 return fmt.Errorf("expected GroupName to be of type string, got %T instead", value) 6538 } 6539 sv.GroupName = ptr.String(jtv) 6540 } 6541 6542 case "InsightId": 6543 if value != nil { 6544 jtv, ok := value.(string) 6545 if !ok { 6546 return fmt.Errorf("expected InsightId to be of type string, got %T instead", value) 6547 } 6548 sv.InsightId = ptr.String(jtv) 6549 } 6550 6551 case "LastUpdateTime": 6552 if value != nil { 6553 jtv, ok := value.(json.Number) 6554 if !ok { 6555 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6556 } 6557 f64, err := jtv.Float64() 6558 if err != nil { 6559 return err 6560 } 6561 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6562 } 6563 6564 case "RootCauseServiceId": 6565 if err := awsRestjson1_deserializeDocumentServiceId(&sv.RootCauseServiceId, value); err != nil { 6566 return err 6567 } 6568 6569 case "RootCauseServiceRequestImpactStatistics": 6570 if err := awsRestjson1_deserializeDocumentRequestImpactStatistics(&sv.RootCauseServiceRequestImpactStatistics, value); err != nil { 6571 return err 6572 } 6573 6574 case "StartTime": 6575 if value != nil { 6576 jtv, ok := value.(json.Number) 6577 if !ok { 6578 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6579 } 6580 f64, err := jtv.Float64() 6581 if err != nil { 6582 return err 6583 } 6584 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6585 } 6586 6587 case "State": 6588 if value != nil { 6589 jtv, ok := value.(string) 6590 if !ok { 6591 return fmt.Errorf("expected InsightState to be of type string, got %T instead", value) 6592 } 6593 sv.State = types.InsightState(jtv) 6594 } 6595 6596 case "Summary": 6597 if value != nil { 6598 jtv, ok := value.(string) 6599 if !ok { 6600 return fmt.Errorf("expected InsightSummaryText to be of type string, got %T instead", value) 6601 } 6602 sv.Summary = ptr.String(jtv) 6603 } 6604 6605 case "TopAnomalousServices": 6606 if err := awsRestjson1_deserializeDocumentAnomalousServiceList(&sv.TopAnomalousServices, value); err != nil { 6607 return err 6608 } 6609 6610 default: 6611 _, _ = key, value 6612 6613 } 6614 } 6615 *v = sv 6616 return nil 6617} 6618 6619func awsRestjson1_deserializeDocumentInsightSummaryList(v *[]types.InsightSummary, value interface{}) error { 6620 if v == nil { 6621 return fmt.Errorf("unexpected nil of type %T", v) 6622 } 6623 if value == nil { 6624 return nil 6625 } 6626 6627 shape, ok := value.([]interface{}) 6628 if !ok { 6629 return fmt.Errorf("unexpected JSON type %v", value) 6630 } 6631 6632 var cv []types.InsightSummary 6633 if *v == nil { 6634 cv = []types.InsightSummary{} 6635 } else { 6636 cv = *v 6637 } 6638 6639 for _, value := range shape { 6640 var col types.InsightSummary 6641 destAddr := &col 6642 if err := awsRestjson1_deserializeDocumentInsightSummary(&destAddr, value); err != nil { 6643 return err 6644 } 6645 col = *destAddr 6646 cv = append(cv, col) 6647 6648 } 6649 *v = cv 6650 return nil 6651} 6652 6653func awsRestjson1_deserializeDocumentInstanceIdDetail(v **types.InstanceIdDetail, value interface{}) error { 6654 if v == nil { 6655 return fmt.Errorf("unexpected nil of type %T", v) 6656 } 6657 if value == nil { 6658 return nil 6659 } 6660 6661 shape, ok := value.(map[string]interface{}) 6662 if !ok { 6663 return fmt.Errorf("unexpected JSON type %v", value) 6664 } 6665 6666 var sv *types.InstanceIdDetail 6667 if *v == nil { 6668 sv = &types.InstanceIdDetail{} 6669 } else { 6670 sv = *v 6671 } 6672 6673 for key, value := range shape { 6674 switch key { 6675 case "Id": 6676 if value != nil { 6677 jtv, ok := value.(string) 6678 if !ok { 6679 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6680 } 6681 sv.Id = ptr.String(jtv) 6682 } 6683 6684 default: 6685 _, _ = key, value 6686 6687 } 6688 } 6689 *v = sv 6690 return nil 6691} 6692 6693func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 6694 if v == nil { 6695 return fmt.Errorf("unexpected nil of type %T", v) 6696 } 6697 if value == nil { 6698 return nil 6699 } 6700 6701 shape, ok := value.(map[string]interface{}) 6702 if !ok { 6703 return fmt.Errorf("unexpected JSON type %v", value) 6704 } 6705 6706 var sv *types.InvalidRequestException 6707 if *v == nil { 6708 sv = &types.InvalidRequestException{} 6709 } else { 6710 sv = *v 6711 } 6712 6713 for key, value := range shape { 6714 switch key { 6715 case "Message": 6716 if value != nil { 6717 jtv, ok := value.(string) 6718 if !ok { 6719 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6720 } 6721 sv.Message = ptr.String(jtv) 6722 } 6723 6724 default: 6725 _, _ = key, value 6726 6727 } 6728 } 6729 *v = sv 6730 return nil 6731} 6732 6733func awsRestjson1_deserializeDocumentRequestImpactStatistics(v **types.RequestImpactStatistics, value interface{}) error { 6734 if v == nil { 6735 return fmt.Errorf("unexpected nil of type %T", v) 6736 } 6737 if value == nil { 6738 return nil 6739 } 6740 6741 shape, ok := value.(map[string]interface{}) 6742 if !ok { 6743 return fmt.Errorf("unexpected JSON type %v", value) 6744 } 6745 6746 var sv *types.RequestImpactStatistics 6747 if *v == nil { 6748 sv = &types.RequestImpactStatistics{} 6749 } else { 6750 sv = *v 6751 } 6752 6753 for key, value := range shape { 6754 switch key { 6755 case "FaultCount": 6756 if value != nil { 6757 jtv, ok := value.(json.Number) 6758 if !ok { 6759 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 6760 } 6761 i64, err := jtv.Int64() 6762 if err != nil { 6763 return err 6764 } 6765 sv.FaultCount = ptr.Int64(i64) 6766 } 6767 6768 case "OkCount": 6769 if value != nil { 6770 jtv, ok := value.(json.Number) 6771 if !ok { 6772 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 6773 } 6774 i64, err := jtv.Int64() 6775 if err != nil { 6776 return err 6777 } 6778 sv.OkCount = ptr.Int64(i64) 6779 } 6780 6781 case "TotalCount": 6782 if value != nil { 6783 jtv, ok := value.(json.Number) 6784 if !ok { 6785 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 6786 } 6787 i64, err := jtv.Int64() 6788 if err != nil { 6789 return err 6790 } 6791 sv.TotalCount = ptr.Int64(i64) 6792 } 6793 6794 default: 6795 _, _ = key, value 6796 6797 } 6798 } 6799 *v = sv 6800 return nil 6801} 6802 6803func awsRestjson1_deserializeDocumentResourceARNDetail(v **types.ResourceARNDetail, value interface{}) error { 6804 if v == nil { 6805 return fmt.Errorf("unexpected nil of type %T", v) 6806 } 6807 if value == nil { 6808 return nil 6809 } 6810 6811 shape, ok := value.(map[string]interface{}) 6812 if !ok { 6813 return fmt.Errorf("unexpected JSON type %v", value) 6814 } 6815 6816 var sv *types.ResourceARNDetail 6817 if *v == nil { 6818 sv = &types.ResourceARNDetail{} 6819 } else { 6820 sv = *v 6821 } 6822 6823 for key, value := range shape { 6824 switch key { 6825 case "ARN": 6826 if value != nil { 6827 jtv, ok := value.(string) 6828 if !ok { 6829 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6830 } 6831 sv.ARN = ptr.String(jtv) 6832 } 6833 6834 default: 6835 _, _ = key, value 6836 6837 } 6838 } 6839 *v = sv 6840 return nil 6841} 6842 6843func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 6844 if v == nil { 6845 return fmt.Errorf("unexpected nil of type %T", v) 6846 } 6847 if value == nil { 6848 return nil 6849 } 6850 6851 shape, ok := value.(map[string]interface{}) 6852 if !ok { 6853 return fmt.Errorf("unexpected JSON type %v", value) 6854 } 6855 6856 var sv *types.ResourceNotFoundException 6857 if *v == nil { 6858 sv = &types.ResourceNotFoundException{} 6859 } else { 6860 sv = *v 6861 } 6862 6863 for key, value := range shape { 6864 switch key { 6865 case "Message": 6866 if value != nil { 6867 jtv, ok := value.(string) 6868 if !ok { 6869 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6870 } 6871 sv.Message = ptr.String(jtv) 6872 } 6873 6874 case "ResourceName": 6875 if value != nil { 6876 jtv, ok := value.(string) 6877 if !ok { 6878 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 6879 } 6880 sv.ResourceName = ptr.String(jtv) 6881 } 6882 6883 default: 6884 _, _ = key, value 6885 6886 } 6887 } 6888 *v = sv 6889 return nil 6890} 6891 6892func awsRestjson1_deserializeDocumentResponseTimeRootCause(v **types.ResponseTimeRootCause, value interface{}) error { 6893 if v == nil { 6894 return fmt.Errorf("unexpected nil of type %T", v) 6895 } 6896 if value == nil { 6897 return nil 6898 } 6899 6900 shape, ok := value.(map[string]interface{}) 6901 if !ok { 6902 return fmt.Errorf("unexpected JSON type %v", value) 6903 } 6904 6905 var sv *types.ResponseTimeRootCause 6906 if *v == nil { 6907 sv = &types.ResponseTimeRootCause{} 6908 } else { 6909 sv = *v 6910 } 6911 6912 for key, value := range shape { 6913 switch key { 6914 case "ClientImpacting": 6915 if value != nil { 6916 jtv, ok := value.(bool) 6917 if !ok { 6918 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 6919 } 6920 sv.ClientImpacting = ptr.Bool(jtv) 6921 } 6922 6923 case "Services": 6924 if err := awsRestjson1_deserializeDocumentResponseTimeRootCauseServices(&sv.Services, value); err != nil { 6925 return err 6926 } 6927 6928 default: 6929 _, _ = key, value 6930 6931 } 6932 } 6933 *v = sv 6934 return nil 6935} 6936 6937func awsRestjson1_deserializeDocumentResponseTimeRootCauseEntity(v **types.ResponseTimeRootCauseEntity, value interface{}) error { 6938 if v == nil { 6939 return fmt.Errorf("unexpected nil of type %T", v) 6940 } 6941 if value == nil { 6942 return nil 6943 } 6944 6945 shape, ok := value.(map[string]interface{}) 6946 if !ok { 6947 return fmt.Errorf("unexpected JSON type %v", value) 6948 } 6949 6950 var sv *types.ResponseTimeRootCauseEntity 6951 if *v == nil { 6952 sv = &types.ResponseTimeRootCauseEntity{} 6953 } else { 6954 sv = *v 6955 } 6956 6957 for key, value := range shape { 6958 switch key { 6959 case "Coverage": 6960 if value != nil { 6961 jtv, ok := value.(json.Number) 6962 if !ok { 6963 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 6964 } 6965 f64, err := jtv.Float64() 6966 if err != nil { 6967 return err 6968 } 6969 sv.Coverage = ptr.Float64(f64) 6970 } 6971 6972 case "Name": 6973 if value != nil { 6974 jtv, ok := value.(string) 6975 if !ok { 6976 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6977 } 6978 sv.Name = ptr.String(jtv) 6979 } 6980 6981 case "Remote": 6982 if value != nil { 6983 jtv, ok := value.(bool) 6984 if !ok { 6985 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 6986 } 6987 sv.Remote = ptr.Bool(jtv) 6988 } 6989 6990 default: 6991 _, _ = key, value 6992 6993 } 6994 } 6995 *v = sv 6996 return nil 6997} 6998 6999func awsRestjson1_deserializeDocumentResponseTimeRootCauseEntityPath(v *[]types.ResponseTimeRootCauseEntity, value interface{}) error { 7000 if v == nil { 7001 return fmt.Errorf("unexpected nil of type %T", v) 7002 } 7003 if value == nil { 7004 return nil 7005 } 7006 7007 shape, ok := value.([]interface{}) 7008 if !ok { 7009 return fmt.Errorf("unexpected JSON type %v", value) 7010 } 7011 7012 var cv []types.ResponseTimeRootCauseEntity 7013 if *v == nil { 7014 cv = []types.ResponseTimeRootCauseEntity{} 7015 } else { 7016 cv = *v 7017 } 7018 7019 for _, value := range shape { 7020 var col types.ResponseTimeRootCauseEntity 7021 destAddr := &col 7022 if err := awsRestjson1_deserializeDocumentResponseTimeRootCauseEntity(&destAddr, value); err != nil { 7023 return err 7024 } 7025 col = *destAddr 7026 cv = append(cv, col) 7027 7028 } 7029 *v = cv 7030 return nil 7031} 7032 7033func awsRestjson1_deserializeDocumentResponseTimeRootCauses(v *[]types.ResponseTimeRootCause, value interface{}) error { 7034 if v == nil { 7035 return fmt.Errorf("unexpected nil of type %T", v) 7036 } 7037 if value == nil { 7038 return nil 7039 } 7040 7041 shape, ok := value.([]interface{}) 7042 if !ok { 7043 return fmt.Errorf("unexpected JSON type %v", value) 7044 } 7045 7046 var cv []types.ResponseTimeRootCause 7047 if *v == nil { 7048 cv = []types.ResponseTimeRootCause{} 7049 } else { 7050 cv = *v 7051 } 7052 7053 for _, value := range shape { 7054 var col types.ResponseTimeRootCause 7055 destAddr := &col 7056 if err := awsRestjson1_deserializeDocumentResponseTimeRootCause(&destAddr, value); err != nil { 7057 return err 7058 } 7059 col = *destAddr 7060 cv = append(cv, col) 7061 7062 } 7063 *v = cv 7064 return nil 7065} 7066 7067func awsRestjson1_deserializeDocumentResponseTimeRootCauseService(v **types.ResponseTimeRootCauseService, value interface{}) error { 7068 if v == nil { 7069 return fmt.Errorf("unexpected nil of type %T", v) 7070 } 7071 if value == nil { 7072 return nil 7073 } 7074 7075 shape, ok := value.(map[string]interface{}) 7076 if !ok { 7077 return fmt.Errorf("unexpected JSON type %v", value) 7078 } 7079 7080 var sv *types.ResponseTimeRootCauseService 7081 if *v == nil { 7082 sv = &types.ResponseTimeRootCauseService{} 7083 } else { 7084 sv = *v 7085 } 7086 7087 for key, value := range shape { 7088 switch key { 7089 case "AccountId": 7090 if value != nil { 7091 jtv, ok := value.(string) 7092 if !ok { 7093 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7094 } 7095 sv.AccountId = ptr.String(jtv) 7096 } 7097 7098 case "EntityPath": 7099 if err := awsRestjson1_deserializeDocumentResponseTimeRootCauseEntityPath(&sv.EntityPath, value); err != nil { 7100 return err 7101 } 7102 7103 case "Inferred": 7104 if value != nil { 7105 jtv, ok := value.(bool) 7106 if !ok { 7107 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 7108 } 7109 sv.Inferred = ptr.Bool(jtv) 7110 } 7111 7112 case "Name": 7113 if value != nil { 7114 jtv, ok := value.(string) 7115 if !ok { 7116 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7117 } 7118 sv.Name = ptr.String(jtv) 7119 } 7120 7121 case "Names": 7122 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 7123 return err 7124 } 7125 7126 case "Type": 7127 if value != nil { 7128 jtv, ok := value.(string) 7129 if !ok { 7130 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7131 } 7132 sv.Type = ptr.String(jtv) 7133 } 7134 7135 default: 7136 _, _ = key, value 7137 7138 } 7139 } 7140 *v = sv 7141 return nil 7142} 7143 7144func awsRestjson1_deserializeDocumentResponseTimeRootCauseServices(v *[]types.ResponseTimeRootCauseService, value interface{}) error { 7145 if v == nil { 7146 return fmt.Errorf("unexpected nil of type %T", v) 7147 } 7148 if value == nil { 7149 return nil 7150 } 7151 7152 shape, ok := value.([]interface{}) 7153 if !ok { 7154 return fmt.Errorf("unexpected JSON type %v", value) 7155 } 7156 7157 var cv []types.ResponseTimeRootCauseService 7158 if *v == nil { 7159 cv = []types.ResponseTimeRootCauseService{} 7160 } else { 7161 cv = *v 7162 } 7163 7164 for _, value := range shape { 7165 var col types.ResponseTimeRootCauseService 7166 destAddr := &col 7167 if err := awsRestjson1_deserializeDocumentResponseTimeRootCauseService(&destAddr, value); err != nil { 7168 return err 7169 } 7170 col = *destAddr 7171 cv = append(cv, col) 7172 7173 } 7174 *v = cv 7175 return nil 7176} 7177 7178func awsRestjson1_deserializeDocumentRootCauseException(v **types.RootCauseException, value interface{}) error { 7179 if v == nil { 7180 return fmt.Errorf("unexpected nil of type %T", v) 7181 } 7182 if value == nil { 7183 return nil 7184 } 7185 7186 shape, ok := value.(map[string]interface{}) 7187 if !ok { 7188 return fmt.Errorf("unexpected JSON type %v", value) 7189 } 7190 7191 var sv *types.RootCauseException 7192 if *v == nil { 7193 sv = &types.RootCauseException{} 7194 } else { 7195 sv = *v 7196 } 7197 7198 for key, value := range shape { 7199 switch key { 7200 case "Message": 7201 if value != nil { 7202 jtv, ok := value.(string) 7203 if !ok { 7204 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7205 } 7206 sv.Message = ptr.String(jtv) 7207 } 7208 7209 case "Name": 7210 if value != nil { 7211 jtv, ok := value.(string) 7212 if !ok { 7213 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7214 } 7215 sv.Name = ptr.String(jtv) 7216 } 7217 7218 default: 7219 _, _ = key, value 7220 7221 } 7222 } 7223 *v = sv 7224 return nil 7225} 7226 7227func awsRestjson1_deserializeDocumentRootCauseExceptions(v *[]types.RootCauseException, value interface{}) error { 7228 if v == nil { 7229 return fmt.Errorf("unexpected nil of type %T", v) 7230 } 7231 if value == nil { 7232 return nil 7233 } 7234 7235 shape, ok := value.([]interface{}) 7236 if !ok { 7237 return fmt.Errorf("unexpected JSON type %v", value) 7238 } 7239 7240 var cv []types.RootCauseException 7241 if *v == nil { 7242 cv = []types.RootCauseException{} 7243 } else { 7244 cv = *v 7245 } 7246 7247 for _, value := range shape { 7248 var col types.RootCauseException 7249 destAddr := &col 7250 if err := awsRestjson1_deserializeDocumentRootCauseException(&destAddr, value); err != nil { 7251 return err 7252 } 7253 col = *destAddr 7254 cv = append(cv, col) 7255 7256 } 7257 *v = cv 7258 return nil 7259} 7260 7261func awsRestjson1_deserializeDocumentRuleLimitExceededException(v **types.RuleLimitExceededException, value interface{}) error { 7262 if v == nil { 7263 return fmt.Errorf("unexpected nil of type %T", v) 7264 } 7265 if value == nil { 7266 return nil 7267 } 7268 7269 shape, ok := value.(map[string]interface{}) 7270 if !ok { 7271 return fmt.Errorf("unexpected JSON type %v", value) 7272 } 7273 7274 var sv *types.RuleLimitExceededException 7275 if *v == nil { 7276 sv = &types.RuleLimitExceededException{} 7277 } else { 7278 sv = *v 7279 } 7280 7281 for key, value := range shape { 7282 switch key { 7283 case "Message": 7284 if value != nil { 7285 jtv, ok := value.(string) 7286 if !ok { 7287 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7288 } 7289 sv.Message = ptr.String(jtv) 7290 } 7291 7292 default: 7293 _, _ = key, value 7294 7295 } 7296 } 7297 *v = sv 7298 return nil 7299} 7300 7301func awsRestjson1_deserializeDocumentSamplingRule(v **types.SamplingRule, value interface{}) error { 7302 if v == nil { 7303 return fmt.Errorf("unexpected nil of type %T", v) 7304 } 7305 if value == nil { 7306 return nil 7307 } 7308 7309 shape, ok := value.(map[string]interface{}) 7310 if !ok { 7311 return fmt.Errorf("unexpected JSON type %v", value) 7312 } 7313 7314 var sv *types.SamplingRule 7315 if *v == nil { 7316 sv = &types.SamplingRule{} 7317 } else { 7318 sv = *v 7319 } 7320 7321 for key, value := range shape { 7322 switch key { 7323 case "Attributes": 7324 if err := awsRestjson1_deserializeDocumentAttributeMap(&sv.Attributes, value); err != nil { 7325 return err 7326 } 7327 7328 case "FixedRate": 7329 if value != nil { 7330 jtv, ok := value.(json.Number) 7331 if !ok { 7332 return fmt.Errorf("expected FixedRate to be json.Number, got %T instead", value) 7333 } 7334 f64, err := jtv.Float64() 7335 if err != nil { 7336 return err 7337 } 7338 sv.FixedRate = f64 7339 } 7340 7341 case "Host": 7342 if value != nil { 7343 jtv, ok := value.(string) 7344 if !ok { 7345 return fmt.Errorf("expected Host to be of type string, got %T instead", value) 7346 } 7347 sv.Host = ptr.String(jtv) 7348 } 7349 7350 case "HTTPMethod": 7351 if value != nil { 7352 jtv, ok := value.(string) 7353 if !ok { 7354 return fmt.Errorf("expected HTTPMethod to be of type string, got %T instead", value) 7355 } 7356 sv.HTTPMethod = ptr.String(jtv) 7357 } 7358 7359 case "Priority": 7360 if value != nil { 7361 jtv, ok := value.(json.Number) 7362 if !ok { 7363 return fmt.Errorf("expected Priority to be json.Number, got %T instead", value) 7364 } 7365 i64, err := jtv.Int64() 7366 if err != nil { 7367 return err 7368 } 7369 sv.Priority = int32(i64) 7370 } 7371 7372 case "ReservoirSize": 7373 if value != nil { 7374 jtv, ok := value.(json.Number) 7375 if !ok { 7376 return fmt.Errorf("expected ReservoirSize to be json.Number, got %T instead", value) 7377 } 7378 i64, err := jtv.Int64() 7379 if err != nil { 7380 return err 7381 } 7382 sv.ReservoirSize = int32(i64) 7383 } 7384 7385 case "ResourceARN": 7386 if value != nil { 7387 jtv, ok := value.(string) 7388 if !ok { 7389 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 7390 } 7391 sv.ResourceARN = ptr.String(jtv) 7392 } 7393 7394 case "RuleARN": 7395 if value != nil { 7396 jtv, ok := value.(string) 7397 if !ok { 7398 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7399 } 7400 sv.RuleARN = ptr.String(jtv) 7401 } 7402 7403 case "RuleName": 7404 if value != nil { 7405 jtv, ok := value.(string) 7406 if !ok { 7407 return fmt.Errorf("expected RuleName to be of type string, got %T instead", value) 7408 } 7409 sv.RuleName = ptr.String(jtv) 7410 } 7411 7412 case "ServiceName": 7413 if value != nil { 7414 jtv, ok := value.(string) 7415 if !ok { 7416 return fmt.Errorf("expected ServiceName to be of type string, got %T instead", value) 7417 } 7418 sv.ServiceName = ptr.String(jtv) 7419 } 7420 7421 case "ServiceType": 7422 if value != nil { 7423 jtv, ok := value.(string) 7424 if !ok { 7425 return fmt.Errorf("expected ServiceType to be of type string, got %T instead", value) 7426 } 7427 sv.ServiceType = ptr.String(jtv) 7428 } 7429 7430 case "URLPath": 7431 if value != nil { 7432 jtv, ok := value.(string) 7433 if !ok { 7434 return fmt.Errorf("expected URLPath to be of type string, got %T instead", value) 7435 } 7436 sv.URLPath = ptr.String(jtv) 7437 } 7438 7439 case "Version": 7440 if value != nil { 7441 jtv, ok := value.(json.Number) 7442 if !ok { 7443 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 7444 } 7445 i64, err := jtv.Int64() 7446 if err != nil { 7447 return err 7448 } 7449 sv.Version = int32(i64) 7450 } 7451 7452 default: 7453 _, _ = key, value 7454 7455 } 7456 } 7457 *v = sv 7458 return nil 7459} 7460 7461func awsRestjson1_deserializeDocumentSamplingRuleRecord(v **types.SamplingRuleRecord, value interface{}) error { 7462 if v == nil { 7463 return fmt.Errorf("unexpected nil of type %T", v) 7464 } 7465 if value == nil { 7466 return nil 7467 } 7468 7469 shape, ok := value.(map[string]interface{}) 7470 if !ok { 7471 return fmt.Errorf("unexpected JSON type %v", value) 7472 } 7473 7474 var sv *types.SamplingRuleRecord 7475 if *v == nil { 7476 sv = &types.SamplingRuleRecord{} 7477 } else { 7478 sv = *v 7479 } 7480 7481 for key, value := range shape { 7482 switch key { 7483 case "CreatedAt": 7484 if value != nil { 7485 jtv, ok := value.(json.Number) 7486 if !ok { 7487 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7488 } 7489 f64, err := jtv.Float64() 7490 if err != nil { 7491 return err 7492 } 7493 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7494 } 7495 7496 case "ModifiedAt": 7497 if value != nil { 7498 jtv, ok := value.(json.Number) 7499 if !ok { 7500 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7501 } 7502 f64, err := jtv.Float64() 7503 if err != nil { 7504 return err 7505 } 7506 sv.ModifiedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7507 } 7508 7509 case "SamplingRule": 7510 if err := awsRestjson1_deserializeDocumentSamplingRule(&sv.SamplingRule, value); err != nil { 7511 return err 7512 } 7513 7514 default: 7515 _, _ = key, value 7516 7517 } 7518 } 7519 *v = sv 7520 return nil 7521} 7522 7523func awsRestjson1_deserializeDocumentSamplingRuleRecordList(v *[]types.SamplingRuleRecord, value interface{}) error { 7524 if v == nil { 7525 return fmt.Errorf("unexpected nil of type %T", v) 7526 } 7527 if value == nil { 7528 return nil 7529 } 7530 7531 shape, ok := value.([]interface{}) 7532 if !ok { 7533 return fmt.Errorf("unexpected JSON type %v", value) 7534 } 7535 7536 var cv []types.SamplingRuleRecord 7537 if *v == nil { 7538 cv = []types.SamplingRuleRecord{} 7539 } else { 7540 cv = *v 7541 } 7542 7543 for _, value := range shape { 7544 var col types.SamplingRuleRecord 7545 destAddr := &col 7546 if err := awsRestjson1_deserializeDocumentSamplingRuleRecord(&destAddr, value); err != nil { 7547 return err 7548 } 7549 col = *destAddr 7550 cv = append(cv, col) 7551 7552 } 7553 *v = cv 7554 return nil 7555} 7556 7557func awsRestjson1_deserializeDocumentSamplingStatisticSummary(v **types.SamplingStatisticSummary, value interface{}) error { 7558 if v == nil { 7559 return fmt.Errorf("unexpected nil of type %T", v) 7560 } 7561 if value == nil { 7562 return nil 7563 } 7564 7565 shape, ok := value.(map[string]interface{}) 7566 if !ok { 7567 return fmt.Errorf("unexpected JSON type %v", value) 7568 } 7569 7570 var sv *types.SamplingStatisticSummary 7571 if *v == nil { 7572 sv = &types.SamplingStatisticSummary{} 7573 } else { 7574 sv = *v 7575 } 7576 7577 for key, value := range shape { 7578 switch key { 7579 case "BorrowCount": 7580 if value != nil { 7581 jtv, ok := value.(json.Number) 7582 if !ok { 7583 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7584 } 7585 i64, err := jtv.Int64() 7586 if err != nil { 7587 return err 7588 } 7589 sv.BorrowCount = int32(i64) 7590 } 7591 7592 case "RequestCount": 7593 if value != nil { 7594 jtv, ok := value.(json.Number) 7595 if !ok { 7596 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7597 } 7598 i64, err := jtv.Int64() 7599 if err != nil { 7600 return err 7601 } 7602 sv.RequestCount = int32(i64) 7603 } 7604 7605 case "RuleName": 7606 if value != nil { 7607 jtv, ok := value.(string) 7608 if !ok { 7609 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7610 } 7611 sv.RuleName = ptr.String(jtv) 7612 } 7613 7614 case "SampledCount": 7615 if value != nil { 7616 jtv, ok := value.(json.Number) 7617 if !ok { 7618 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7619 } 7620 i64, err := jtv.Int64() 7621 if err != nil { 7622 return err 7623 } 7624 sv.SampledCount = int32(i64) 7625 } 7626 7627 case "Timestamp": 7628 if value != nil { 7629 jtv, ok := value.(json.Number) 7630 if !ok { 7631 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7632 } 7633 f64, err := jtv.Float64() 7634 if err != nil { 7635 return err 7636 } 7637 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7638 } 7639 7640 default: 7641 _, _ = key, value 7642 7643 } 7644 } 7645 *v = sv 7646 return nil 7647} 7648 7649func awsRestjson1_deserializeDocumentSamplingStatisticSummaryList(v *[]types.SamplingStatisticSummary, value interface{}) error { 7650 if v == nil { 7651 return fmt.Errorf("unexpected nil of type %T", v) 7652 } 7653 if value == nil { 7654 return nil 7655 } 7656 7657 shape, ok := value.([]interface{}) 7658 if !ok { 7659 return fmt.Errorf("unexpected JSON type %v", value) 7660 } 7661 7662 var cv []types.SamplingStatisticSummary 7663 if *v == nil { 7664 cv = []types.SamplingStatisticSummary{} 7665 } else { 7666 cv = *v 7667 } 7668 7669 for _, value := range shape { 7670 var col types.SamplingStatisticSummary 7671 destAddr := &col 7672 if err := awsRestjson1_deserializeDocumentSamplingStatisticSummary(&destAddr, value); err != nil { 7673 return err 7674 } 7675 col = *destAddr 7676 cv = append(cv, col) 7677 7678 } 7679 *v = cv 7680 return nil 7681} 7682 7683func awsRestjson1_deserializeDocumentSamplingTargetDocument(v **types.SamplingTargetDocument, value interface{}) error { 7684 if v == nil { 7685 return fmt.Errorf("unexpected nil of type %T", v) 7686 } 7687 if value == nil { 7688 return nil 7689 } 7690 7691 shape, ok := value.(map[string]interface{}) 7692 if !ok { 7693 return fmt.Errorf("unexpected JSON type %v", value) 7694 } 7695 7696 var sv *types.SamplingTargetDocument 7697 if *v == nil { 7698 sv = &types.SamplingTargetDocument{} 7699 } else { 7700 sv = *v 7701 } 7702 7703 for key, value := range shape { 7704 switch key { 7705 case "FixedRate": 7706 if value != nil { 7707 jtv, ok := value.(json.Number) 7708 if !ok { 7709 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 7710 } 7711 f64, err := jtv.Float64() 7712 if err != nil { 7713 return err 7714 } 7715 sv.FixedRate = f64 7716 } 7717 7718 case "Interval": 7719 if value != nil { 7720 jtv, ok := value.(json.Number) 7721 if !ok { 7722 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 7723 } 7724 i64, err := jtv.Int64() 7725 if err != nil { 7726 return err 7727 } 7728 sv.Interval = ptr.Int32(int32(i64)) 7729 } 7730 7731 case "ReservoirQuota": 7732 if value != nil { 7733 jtv, ok := value.(json.Number) 7734 if !ok { 7735 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 7736 } 7737 i64, err := jtv.Int64() 7738 if err != nil { 7739 return err 7740 } 7741 sv.ReservoirQuota = ptr.Int32(int32(i64)) 7742 } 7743 7744 case "ReservoirQuotaTTL": 7745 if value != nil { 7746 jtv, ok := value.(json.Number) 7747 if !ok { 7748 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7749 } 7750 f64, err := jtv.Float64() 7751 if err != nil { 7752 return err 7753 } 7754 sv.ReservoirQuotaTTL = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7755 } 7756 7757 case "RuleName": 7758 if value != nil { 7759 jtv, ok := value.(string) 7760 if !ok { 7761 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7762 } 7763 sv.RuleName = ptr.String(jtv) 7764 } 7765 7766 default: 7767 _, _ = key, value 7768 7769 } 7770 } 7771 *v = sv 7772 return nil 7773} 7774 7775func awsRestjson1_deserializeDocumentSamplingTargetDocumentList(v *[]types.SamplingTargetDocument, value interface{}) error { 7776 if v == nil { 7777 return fmt.Errorf("unexpected nil of type %T", v) 7778 } 7779 if value == nil { 7780 return nil 7781 } 7782 7783 shape, ok := value.([]interface{}) 7784 if !ok { 7785 return fmt.Errorf("unexpected JSON type %v", value) 7786 } 7787 7788 var cv []types.SamplingTargetDocument 7789 if *v == nil { 7790 cv = []types.SamplingTargetDocument{} 7791 } else { 7792 cv = *v 7793 } 7794 7795 for _, value := range shape { 7796 var col types.SamplingTargetDocument 7797 destAddr := &col 7798 if err := awsRestjson1_deserializeDocumentSamplingTargetDocument(&destAddr, value); err != nil { 7799 return err 7800 } 7801 col = *destAddr 7802 cv = append(cv, col) 7803 7804 } 7805 *v = cv 7806 return nil 7807} 7808 7809func awsRestjson1_deserializeDocumentSegment(v **types.Segment, value interface{}) error { 7810 if v == nil { 7811 return fmt.Errorf("unexpected nil of type %T", v) 7812 } 7813 if value == nil { 7814 return nil 7815 } 7816 7817 shape, ok := value.(map[string]interface{}) 7818 if !ok { 7819 return fmt.Errorf("unexpected JSON type %v", value) 7820 } 7821 7822 var sv *types.Segment 7823 if *v == nil { 7824 sv = &types.Segment{} 7825 } else { 7826 sv = *v 7827 } 7828 7829 for key, value := range shape { 7830 switch key { 7831 case "Document": 7832 if value != nil { 7833 jtv, ok := value.(string) 7834 if !ok { 7835 return fmt.Errorf("expected SegmentDocument to be of type string, got %T instead", value) 7836 } 7837 sv.Document = ptr.String(jtv) 7838 } 7839 7840 case "Id": 7841 if value != nil { 7842 jtv, ok := value.(string) 7843 if !ok { 7844 return fmt.Errorf("expected SegmentId to be of type string, got %T instead", value) 7845 } 7846 sv.Id = ptr.String(jtv) 7847 } 7848 7849 default: 7850 _, _ = key, value 7851 7852 } 7853 } 7854 *v = sv 7855 return nil 7856} 7857 7858func awsRestjson1_deserializeDocumentSegmentList(v *[]types.Segment, value interface{}) error { 7859 if v == nil { 7860 return fmt.Errorf("unexpected nil of type %T", v) 7861 } 7862 if value == nil { 7863 return nil 7864 } 7865 7866 shape, ok := value.([]interface{}) 7867 if !ok { 7868 return fmt.Errorf("unexpected JSON type %v", value) 7869 } 7870 7871 var cv []types.Segment 7872 if *v == nil { 7873 cv = []types.Segment{} 7874 } else { 7875 cv = *v 7876 } 7877 7878 for _, value := range shape { 7879 var col types.Segment 7880 destAddr := &col 7881 if err := awsRestjson1_deserializeDocumentSegment(&destAddr, value); err != nil { 7882 return err 7883 } 7884 col = *destAddr 7885 cv = append(cv, col) 7886 7887 } 7888 *v = cv 7889 return nil 7890} 7891 7892func awsRestjson1_deserializeDocumentService(v **types.Service, value interface{}) error { 7893 if v == nil { 7894 return fmt.Errorf("unexpected nil of type %T", v) 7895 } 7896 if value == nil { 7897 return nil 7898 } 7899 7900 shape, ok := value.(map[string]interface{}) 7901 if !ok { 7902 return fmt.Errorf("unexpected JSON type %v", value) 7903 } 7904 7905 var sv *types.Service 7906 if *v == nil { 7907 sv = &types.Service{} 7908 } else { 7909 sv = *v 7910 } 7911 7912 for key, value := range shape { 7913 switch key { 7914 case "AccountId": 7915 if value != nil { 7916 jtv, ok := value.(string) 7917 if !ok { 7918 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7919 } 7920 sv.AccountId = ptr.String(jtv) 7921 } 7922 7923 case "DurationHistogram": 7924 if err := awsRestjson1_deserializeDocumentHistogram(&sv.DurationHistogram, value); err != nil { 7925 return err 7926 } 7927 7928 case "Edges": 7929 if err := awsRestjson1_deserializeDocumentEdgeList(&sv.Edges, value); err != nil { 7930 return err 7931 } 7932 7933 case "EndTime": 7934 if value != nil { 7935 jtv, ok := value.(json.Number) 7936 if !ok { 7937 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7938 } 7939 f64, err := jtv.Float64() 7940 if err != nil { 7941 return err 7942 } 7943 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7944 } 7945 7946 case "Name": 7947 if value != nil { 7948 jtv, ok := value.(string) 7949 if !ok { 7950 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7951 } 7952 sv.Name = ptr.String(jtv) 7953 } 7954 7955 case "Names": 7956 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 7957 return err 7958 } 7959 7960 case "ReferenceId": 7961 if value != nil { 7962 jtv, ok := value.(json.Number) 7963 if !ok { 7964 return fmt.Errorf("expected NullableInteger to be json.Number, got %T instead", value) 7965 } 7966 i64, err := jtv.Int64() 7967 if err != nil { 7968 return err 7969 } 7970 sv.ReferenceId = ptr.Int32(int32(i64)) 7971 } 7972 7973 case "ResponseTimeHistogram": 7974 if err := awsRestjson1_deserializeDocumentHistogram(&sv.ResponseTimeHistogram, value); err != nil { 7975 return err 7976 } 7977 7978 case "Root": 7979 if value != nil { 7980 jtv, ok := value.(bool) 7981 if !ok { 7982 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 7983 } 7984 sv.Root = ptr.Bool(jtv) 7985 } 7986 7987 case "StartTime": 7988 if value != nil { 7989 jtv, ok := value.(json.Number) 7990 if !ok { 7991 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7992 } 7993 f64, err := jtv.Float64() 7994 if err != nil { 7995 return err 7996 } 7997 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7998 } 7999 8000 case "State": 8001 if value != nil { 8002 jtv, ok := value.(string) 8003 if !ok { 8004 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8005 } 8006 sv.State = ptr.String(jtv) 8007 } 8008 8009 case "SummaryStatistics": 8010 if err := awsRestjson1_deserializeDocumentServiceStatistics(&sv.SummaryStatistics, value); err != nil { 8011 return err 8012 } 8013 8014 case "Type": 8015 if value != nil { 8016 jtv, ok := value.(string) 8017 if !ok { 8018 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8019 } 8020 sv.Type = ptr.String(jtv) 8021 } 8022 8023 default: 8024 _, _ = key, value 8025 8026 } 8027 } 8028 *v = sv 8029 return nil 8030} 8031 8032func awsRestjson1_deserializeDocumentServiceId(v **types.ServiceId, value interface{}) error { 8033 if v == nil { 8034 return fmt.Errorf("unexpected nil of type %T", v) 8035 } 8036 if value == nil { 8037 return nil 8038 } 8039 8040 shape, ok := value.(map[string]interface{}) 8041 if !ok { 8042 return fmt.Errorf("unexpected JSON type %v", value) 8043 } 8044 8045 var sv *types.ServiceId 8046 if *v == nil { 8047 sv = &types.ServiceId{} 8048 } else { 8049 sv = *v 8050 } 8051 8052 for key, value := range shape { 8053 switch key { 8054 case "AccountId": 8055 if value != nil { 8056 jtv, ok := value.(string) 8057 if !ok { 8058 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8059 } 8060 sv.AccountId = ptr.String(jtv) 8061 } 8062 8063 case "Name": 8064 if value != nil { 8065 jtv, ok := value.(string) 8066 if !ok { 8067 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8068 } 8069 sv.Name = ptr.String(jtv) 8070 } 8071 8072 case "Names": 8073 if err := awsRestjson1_deserializeDocumentServiceNames(&sv.Names, value); err != nil { 8074 return err 8075 } 8076 8077 case "Type": 8078 if value != nil { 8079 jtv, ok := value.(string) 8080 if !ok { 8081 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8082 } 8083 sv.Type = ptr.String(jtv) 8084 } 8085 8086 default: 8087 _, _ = key, value 8088 8089 } 8090 } 8091 *v = sv 8092 return nil 8093} 8094 8095func awsRestjson1_deserializeDocumentServiceIds(v *[]types.ServiceId, value interface{}) error { 8096 if v == nil { 8097 return fmt.Errorf("unexpected nil of type %T", v) 8098 } 8099 if value == nil { 8100 return nil 8101 } 8102 8103 shape, ok := value.([]interface{}) 8104 if !ok { 8105 return fmt.Errorf("unexpected JSON type %v", value) 8106 } 8107 8108 var cv []types.ServiceId 8109 if *v == nil { 8110 cv = []types.ServiceId{} 8111 } else { 8112 cv = *v 8113 } 8114 8115 for _, value := range shape { 8116 var col types.ServiceId 8117 destAddr := &col 8118 if err := awsRestjson1_deserializeDocumentServiceId(&destAddr, value); err != nil { 8119 return err 8120 } 8121 col = *destAddr 8122 cv = append(cv, col) 8123 8124 } 8125 *v = cv 8126 return nil 8127} 8128 8129func awsRestjson1_deserializeDocumentServiceList(v *[]types.Service, value interface{}) error { 8130 if v == nil { 8131 return fmt.Errorf("unexpected nil of type %T", v) 8132 } 8133 if value == nil { 8134 return nil 8135 } 8136 8137 shape, ok := value.([]interface{}) 8138 if !ok { 8139 return fmt.Errorf("unexpected JSON type %v", value) 8140 } 8141 8142 var cv []types.Service 8143 if *v == nil { 8144 cv = []types.Service{} 8145 } else { 8146 cv = *v 8147 } 8148 8149 for _, value := range shape { 8150 var col types.Service 8151 destAddr := &col 8152 if err := awsRestjson1_deserializeDocumentService(&destAddr, value); err != nil { 8153 return err 8154 } 8155 col = *destAddr 8156 cv = append(cv, col) 8157 8158 } 8159 *v = cv 8160 return nil 8161} 8162 8163func awsRestjson1_deserializeDocumentServiceNames(v *[]string, value interface{}) error { 8164 if v == nil { 8165 return fmt.Errorf("unexpected nil of type %T", v) 8166 } 8167 if value == nil { 8168 return nil 8169 } 8170 8171 shape, ok := value.([]interface{}) 8172 if !ok { 8173 return fmt.Errorf("unexpected JSON type %v", value) 8174 } 8175 8176 var cv []string 8177 if *v == nil { 8178 cv = []string{} 8179 } else { 8180 cv = *v 8181 } 8182 8183 for _, value := range shape { 8184 var col string 8185 if value != nil { 8186 jtv, ok := value.(string) 8187 if !ok { 8188 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8189 } 8190 col = jtv 8191 } 8192 cv = append(cv, col) 8193 8194 } 8195 *v = cv 8196 return nil 8197} 8198 8199func awsRestjson1_deserializeDocumentServiceStatistics(v **types.ServiceStatistics, value interface{}) error { 8200 if v == nil { 8201 return fmt.Errorf("unexpected nil of type %T", v) 8202 } 8203 if value == nil { 8204 return nil 8205 } 8206 8207 shape, ok := value.(map[string]interface{}) 8208 if !ok { 8209 return fmt.Errorf("unexpected JSON type %v", value) 8210 } 8211 8212 var sv *types.ServiceStatistics 8213 if *v == nil { 8214 sv = &types.ServiceStatistics{} 8215 } else { 8216 sv = *v 8217 } 8218 8219 for key, value := range shape { 8220 switch key { 8221 case "ErrorStatistics": 8222 if err := awsRestjson1_deserializeDocumentErrorStatistics(&sv.ErrorStatistics, value); err != nil { 8223 return err 8224 } 8225 8226 case "FaultStatistics": 8227 if err := awsRestjson1_deserializeDocumentFaultStatistics(&sv.FaultStatistics, value); err != nil { 8228 return err 8229 } 8230 8231 case "OkCount": 8232 if value != nil { 8233 jtv, ok := value.(json.Number) 8234 if !ok { 8235 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 8236 } 8237 i64, err := jtv.Int64() 8238 if err != nil { 8239 return err 8240 } 8241 sv.OkCount = ptr.Int64(i64) 8242 } 8243 8244 case "TotalCount": 8245 if value != nil { 8246 jtv, ok := value.(json.Number) 8247 if !ok { 8248 return fmt.Errorf("expected NullableLong to be json.Number, got %T instead", value) 8249 } 8250 i64, err := jtv.Int64() 8251 if err != nil { 8252 return err 8253 } 8254 sv.TotalCount = ptr.Int64(i64) 8255 } 8256 8257 case "TotalResponseTime": 8258 if value != nil { 8259 jtv, ok := value.(json.Number) 8260 if !ok { 8261 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 8262 } 8263 f64, err := jtv.Float64() 8264 if err != nil { 8265 return err 8266 } 8267 sv.TotalResponseTime = ptr.Float64(f64) 8268 } 8269 8270 default: 8271 _, _ = key, value 8272 8273 } 8274 } 8275 *v = sv 8276 return nil 8277} 8278 8279func awsRestjson1_deserializeDocumentTag(v **types.Tag, value interface{}) error { 8280 if v == nil { 8281 return fmt.Errorf("unexpected nil of type %T", v) 8282 } 8283 if value == nil { 8284 return nil 8285 } 8286 8287 shape, ok := value.(map[string]interface{}) 8288 if !ok { 8289 return fmt.Errorf("unexpected JSON type %v", value) 8290 } 8291 8292 var sv *types.Tag 8293 if *v == nil { 8294 sv = &types.Tag{} 8295 } else { 8296 sv = *v 8297 } 8298 8299 for key, value := range shape { 8300 switch key { 8301 case "Key": 8302 if value != nil { 8303 jtv, ok := value.(string) 8304 if !ok { 8305 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 8306 } 8307 sv.Key = ptr.String(jtv) 8308 } 8309 8310 case "Value": 8311 if value != nil { 8312 jtv, ok := value.(string) 8313 if !ok { 8314 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 8315 } 8316 sv.Value = ptr.String(jtv) 8317 } 8318 8319 default: 8320 _, _ = key, value 8321 8322 } 8323 } 8324 *v = sv 8325 return nil 8326} 8327 8328func awsRestjson1_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 8329 if v == nil { 8330 return fmt.Errorf("unexpected nil of type %T", v) 8331 } 8332 if value == nil { 8333 return nil 8334 } 8335 8336 shape, ok := value.([]interface{}) 8337 if !ok { 8338 return fmt.Errorf("unexpected JSON type %v", value) 8339 } 8340 8341 var cv []types.Tag 8342 if *v == nil { 8343 cv = []types.Tag{} 8344 } else { 8345 cv = *v 8346 } 8347 8348 for _, value := range shape { 8349 var col types.Tag 8350 destAddr := &col 8351 if err := awsRestjson1_deserializeDocumentTag(&destAddr, value); err != nil { 8352 return err 8353 } 8354 col = *destAddr 8355 cv = append(cv, col) 8356 8357 } 8358 *v = cv 8359 return nil 8360} 8361 8362func awsRestjson1_deserializeDocumentThrottledException(v **types.ThrottledException, value interface{}) error { 8363 if v == nil { 8364 return fmt.Errorf("unexpected nil of type %T", v) 8365 } 8366 if value == nil { 8367 return nil 8368 } 8369 8370 shape, ok := value.(map[string]interface{}) 8371 if !ok { 8372 return fmt.Errorf("unexpected JSON type %v", value) 8373 } 8374 8375 var sv *types.ThrottledException 8376 if *v == nil { 8377 sv = &types.ThrottledException{} 8378 } else { 8379 sv = *v 8380 } 8381 8382 for key, value := range shape { 8383 switch key { 8384 case "Message": 8385 if value != nil { 8386 jtv, ok := value.(string) 8387 if !ok { 8388 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8389 } 8390 sv.Message = ptr.String(jtv) 8391 } 8392 8393 default: 8394 _, _ = key, value 8395 8396 } 8397 } 8398 *v = sv 8399 return nil 8400} 8401 8402func awsRestjson1_deserializeDocumentTimeSeriesServiceStatistics(v **types.TimeSeriesServiceStatistics, value interface{}) error { 8403 if v == nil { 8404 return fmt.Errorf("unexpected nil of type %T", v) 8405 } 8406 if value == nil { 8407 return nil 8408 } 8409 8410 shape, ok := value.(map[string]interface{}) 8411 if !ok { 8412 return fmt.Errorf("unexpected JSON type %v", value) 8413 } 8414 8415 var sv *types.TimeSeriesServiceStatistics 8416 if *v == nil { 8417 sv = &types.TimeSeriesServiceStatistics{} 8418 } else { 8419 sv = *v 8420 } 8421 8422 for key, value := range shape { 8423 switch key { 8424 case "EdgeSummaryStatistics": 8425 if err := awsRestjson1_deserializeDocumentEdgeStatistics(&sv.EdgeSummaryStatistics, value); err != nil { 8426 return err 8427 } 8428 8429 case "ResponseTimeHistogram": 8430 if err := awsRestjson1_deserializeDocumentHistogram(&sv.ResponseTimeHistogram, value); err != nil { 8431 return err 8432 } 8433 8434 case "ServiceForecastStatistics": 8435 if err := awsRestjson1_deserializeDocumentForecastStatistics(&sv.ServiceForecastStatistics, value); err != nil { 8436 return err 8437 } 8438 8439 case "ServiceSummaryStatistics": 8440 if err := awsRestjson1_deserializeDocumentServiceStatistics(&sv.ServiceSummaryStatistics, value); err != nil { 8441 return err 8442 } 8443 8444 case "Timestamp": 8445 if value != nil { 8446 jtv, ok := value.(json.Number) 8447 if !ok { 8448 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8449 } 8450 f64, err := jtv.Float64() 8451 if err != nil { 8452 return err 8453 } 8454 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8455 } 8456 8457 default: 8458 _, _ = key, value 8459 8460 } 8461 } 8462 *v = sv 8463 return nil 8464} 8465 8466func awsRestjson1_deserializeDocumentTimeSeriesServiceStatisticsList(v *[]types.TimeSeriesServiceStatistics, value interface{}) error { 8467 if v == nil { 8468 return fmt.Errorf("unexpected nil of type %T", v) 8469 } 8470 if value == nil { 8471 return nil 8472 } 8473 8474 shape, ok := value.([]interface{}) 8475 if !ok { 8476 return fmt.Errorf("unexpected JSON type %v", value) 8477 } 8478 8479 var cv []types.TimeSeriesServiceStatistics 8480 if *v == nil { 8481 cv = []types.TimeSeriesServiceStatistics{} 8482 } else { 8483 cv = *v 8484 } 8485 8486 for _, value := range shape { 8487 var col types.TimeSeriesServiceStatistics 8488 destAddr := &col 8489 if err := awsRestjson1_deserializeDocumentTimeSeriesServiceStatistics(&destAddr, value); err != nil { 8490 return err 8491 } 8492 col = *destAddr 8493 cv = append(cv, col) 8494 8495 } 8496 *v = cv 8497 return nil 8498} 8499 8500func awsRestjson1_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 8501 if v == nil { 8502 return fmt.Errorf("unexpected nil of type %T", v) 8503 } 8504 if value == nil { 8505 return nil 8506 } 8507 8508 shape, ok := value.(map[string]interface{}) 8509 if !ok { 8510 return fmt.Errorf("unexpected JSON type %v", value) 8511 } 8512 8513 var sv *types.TooManyTagsException 8514 if *v == nil { 8515 sv = &types.TooManyTagsException{} 8516 } else { 8517 sv = *v 8518 } 8519 8520 for key, value := range shape { 8521 switch key { 8522 case "Message": 8523 if value != nil { 8524 jtv, ok := value.(string) 8525 if !ok { 8526 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8527 } 8528 sv.Message = ptr.String(jtv) 8529 } 8530 8531 case "ResourceName": 8532 if value != nil { 8533 jtv, ok := value.(string) 8534 if !ok { 8535 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 8536 } 8537 sv.ResourceName = ptr.String(jtv) 8538 } 8539 8540 default: 8541 _, _ = key, value 8542 8543 } 8544 } 8545 *v = sv 8546 return nil 8547} 8548 8549func awsRestjson1_deserializeDocumentTrace(v **types.Trace, value interface{}) error { 8550 if v == nil { 8551 return fmt.Errorf("unexpected nil of type %T", v) 8552 } 8553 if value == nil { 8554 return nil 8555 } 8556 8557 shape, ok := value.(map[string]interface{}) 8558 if !ok { 8559 return fmt.Errorf("unexpected JSON type %v", value) 8560 } 8561 8562 var sv *types.Trace 8563 if *v == nil { 8564 sv = &types.Trace{} 8565 } else { 8566 sv = *v 8567 } 8568 8569 for key, value := range shape { 8570 switch key { 8571 case "Duration": 8572 if value != nil { 8573 jtv, ok := value.(json.Number) 8574 if !ok { 8575 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 8576 } 8577 f64, err := jtv.Float64() 8578 if err != nil { 8579 return err 8580 } 8581 sv.Duration = ptr.Float64(f64) 8582 } 8583 8584 case "Id": 8585 if value != nil { 8586 jtv, ok := value.(string) 8587 if !ok { 8588 return fmt.Errorf("expected TraceId to be of type string, got %T instead", value) 8589 } 8590 sv.Id = ptr.String(jtv) 8591 } 8592 8593 case "LimitExceeded": 8594 if value != nil { 8595 jtv, ok := value.(bool) 8596 if !ok { 8597 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 8598 } 8599 sv.LimitExceeded = ptr.Bool(jtv) 8600 } 8601 8602 case "Segments": 8603 if err := awsRestjson1_deserializeDocumentSegmentList(&sv.Segments, value); err != nil { 8604 return err 8605 } 8606 8607 default: 8608 _, _ = key, value 8609 8610 } 8611 } 8612 *v = sv 8613 return nil 8614} 8615 8616func awsRestjson1_deserializeDocumentTraceAvailabilityZones(v *[]types.AvailabilityZoneDetail, value interface{}) error { 8617 if v == nil { 8618 return fmt.Errorf("unexpected nil of type %T", v) 8619 } 8620 if value == nil { 8621 return nil 8622 } 8623 8624 shape, ok := value.([]interface{}) 8625 if !ok { 8626 return fmt.Errorf("unexpected JSON type %v", value) 8627 } 8628 8629 var cv []types.AvailabilityZoneDetail 8630 if *v == nil { 8631 cv = []types.AvailabilityZoneDetail{} 8632 } else { 8633 cv = *v 8634 } 8635 8636 for _, value := range shape { 8637 var col types.AvailabilityZoneDetail 8638 destAddr := &col 8639 if err := awsRestjson1_deserializeDocumentAvailabilityZoneDetail(&destAddr, value); err != nil { 8640 return err 8641 } 8642 col = *destAddr 8643 cv = append(cv, col) 8644 8645 } 8646 *v = cv 8647 return nil 8648} 8649 8650func awsRestjson1_deserializeDocumentTraceInstanceIds(v *[]types.InstanceIdDetail, value interface{}) error { 8651 if v == nil { 8652 return fmt.Errorf("unexpected nil of type %T", v) 8653 } 8654 if value == nil { 8655 return nil 8656 } 8657 8658 shape, ok := value.([]interface{}) 8659 if !ok { 8660 return fmt.Errorf("unexpected JSON type %v", value) 8661 } 8662 8663 var cv []types.InstanceIdDetail 8664 if *v == nil { 8665 cv = []types.InstanceIdDetail{} 8666 } else { 8667 cv = *v 8668 } 8669 8670 for _, value := range shape { 8671 var col types.InstanceIdDetail 8672 destAddr := &col 8673 if err := awsRestjson1_deserializeDocumentInstanceIdDetail(&destAddr, value); err != nil { 8674 return err 8675 } 8676 col = *destAddr 8677 cv = append(cv, col) 8678 8679 } 8680 *v = cv 8681 return nil 8682} 8683 8684func awsRestjson1_deserializeDocumentTraceList(v *[]types.Trace, value interface{}) error { 8685 if v == nil { 8686 return fmt.Errorf("unexpected nil of type %T", v) 8687 } 8688 if value == nil { 8689 return nil 8690 } 8691 8692 shape, ok := value.([]interface{}) 8693 if !ok { 8694 return fmt.Errorf("unexpected JSON type %v", value) 8695 } 8696 8697 var cv []types.Trace 8698 if *v == nil { 8699 cv = []types.Trace{} 8700 } else { 8701 cv = *v 8702 } 8703 8704 for _, value := range shape { 8705 var col types.Trace 8706 destAddr := &col 8707 if err := awsRestjson1_deserializeDocumentTrace(&destAddr, value); err != nil { 8708 return err 8709 } 8710 col = *destAddr 8711 cv = append(cv, col) 8712 8713 } 8714 *v = cv 8715 return nil 8716} 8717 8718func awsRestjson1_deserializeDocumentTraceResourceARNs(v *[]types.ResourceARNDetail, value interface{}) error { 8719 if v == nil { 8720 return fmt.Errorf("unexpected nil of type %T", v) 8721 } 8722 if value == nil { 8723 return nil 8724 } 8725 8726 shape, ok := value.([]interface{}) 8727 if !ok { 8728 return fmt.Errorf("unexpected JSON type %v", value) 8729 } 8730 8731 var cv []types.ResourceARNDetail 8732 if *v == nil { 8733 cv = []types.ResourceARNDetail{} 8734 } else { 8735 cv = *v 8736 } 8737 8738 for _, value := range shape { 8739 var col types.ResourceARNDetail 8740 destAddr := &col 8741 if err := awsRestjson1_deserializeDocumentResourceARNDetail(&destAddr, value); err != nil { 8742 return err 8743 } 8744 col = *destAddr 8745 cv = append(cv, col) 8746 8747 } 8748 *v = cv 8749 return nil 8750} 8751 8752func awsRestjson1_deserializeDocumentTraceSummary(v **types.TraceSummary, value interface{}) error { 8753 if v == nil { 8754 return fmt.Errorf("unexpected nil of type %T", v) 8755 } 8756 if value == nil { 8757 return nil 8758 } 8759 8760 shape, ok := value.(map[string]interface{}) 8761 if !ok { 8762 return fmt.Errorf("unexpected JSON type %v", value) 8763 } 8764 8765 var sv *types.TraceSummary 8766 if *v == nil { 8767 sv = &types.TraceSummary{} 8768 } else { 8769 sv = *v 8770 } 8771 8772 for key, value := range shape { 8773 switch key { 8774 case "Annotations": 8775 if err := awsRestjson1_deserializeDocumentAnnotations(&sv.Annotations, value); err != nil { 8776 return err 8777 } 8778 8779 case "AvailabilityZones": 8780 if err := awsRestjson1_deserializeDocumentTraceAvailabilityZones(&sv.AvailabilityZones, value); err != nil { 8781 return err 8782 } 8783 8784 case "Duration": 8785 if value != nil { 8786 jtv, ok := value.(json.Number) 8787 if !ok { 8788 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 8789 } 8790 f64, err := jtv.Float64() 8791 if err != nil { 8792 return err 8793 } 8794 sv.Duration = ptr.Float64(f64) 8795 } 8796 8797 case "EntryPoint": 8798 if err := awsRestjson1_deserializeDocumentServiceId(&sv.EntryPoint, value); err != nil { 8799 return err 8800 } 8801 8802 case "ErrorRootCauses": 8803 if err := awsRestjson1_deserializeDocumentErrorRootCauses(&sv.ErrorRootCauses, value); err != nil { 8804 return err 8805 } 8806 8807 case "FaultRootCauses": 8808 if err := awsRestjson1_deserializeDocumentFaultRootCauses(&sv.FaultRootCauses, value); err != nil { 8809 return err 8810 } 8811 8812 case "HasError": 8813 if value != nil { 8814 jtv, ok := value.(bool) 8815 if !ok { 8816 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 8817 } 8818 sv.HasError = ptr.Bool(jtv) 8819 } 8820 8821 case "HasFault": 8822 if value != nil { 8823 jtv, ok := value.(bool) 8824 if !ok { 8825 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 8826 } 8827 sv.HasFault = ptr.Bool(jtv) 8828 } 8829 8830 case "HasThrottle": 8831 if value != nil { 8832 jtv, ok := value.(bool) 8833 if !ok { 8834 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 8835 } 8836 sv.HasThrottle = ptr.Bool(jtv) 8837 } 8838 8839 case "Http": 8840 if err := awsRestjson1_deserializeDocumentHttp(&sv.Http, value); err != nil { 8841 return err 8842 } 8843 8844 case "Id": 8845 if value != nil { 8846 jtv, ok := value.(string) 8847 if !ok { 8848 return fmt.Errorf("expected TraceId to be of type string, got %T instead", value) 8849 } 8850 sv.Id = ptr.String(jtv) 8851 } 8852 8853 case "InstanceIds": 8854 if err := awsRestjson1_deserializeDocumentTraceInstanceIds(&sv.InstanceIds, value); err != nil { 8855 return err 8856 } 8857 8858 case "IsPartial": 8859 if value != nil { 8860 jtv, ok := value.(bool) 8861 if !ok { 8862 return fmt.Errorf("expected NullableBoolean to be of type *bool, got %T instead", value) 8863 } 8864 sv.IsPartial = ptr.Bool(jtv) 8865 } 8866 8867 case "MatchedEventTime": 8868 if value != nil { 8869 jtv, ok := value.(json.Number) 8870 if !ok { 8871 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8872 } 8873 f64, err := jtv.Float64() 8874 if err != nil { 8875 return err 8876 } 8877 sv.MatchedEventTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8878 } 8879 8880 case "ResourceARNs": 8881 if err := awsRestjson1_deserializeDocumentTraceResourceARNs(&sv.ResourceARNs, value); err != nil { 8882 return err 8883 } 8884 8885 case "ResponseTime": 8886 if value != nil { 8887 jtv, ok := value.(json.Number) 8888 if !ok { 8889 return fmt.Errorf("expected NullableDouble to be json.Number, got %T instead", value) 8890 } 8891 f64, err := jtv.Float64() 8892 if err != nil { 8893 return err 8894 } 8895 sv.ResponseTime = ptr.Float64(f64) 8896 } 8897 8898 case "ResponseTimeRootCauses": 8899 if err := awsRestjson1_deserializeDocumentResponseTimeRootCauses(&sv.ResponseTimeRootCauses, value); err != nil { 8900 return err 8901 } 8902 8903 case "Revision": 8904 if value != nil { 8905 jtv, ok := value.(json.Number) 8906 if !ok { 8907 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8908 } 8909 i64, err := jtv.Int64() 8910 if err != nil { 8911 return err 8912 } 8913 sv.Revision = int32(i64) 8914 } 8915 8916 case "ServiceIds": 8917 if err := awsRestjson1_deserializeDocumentServiceIds(&sv.ServiceIds, value); err != nil { 8918 return err 8919 } 8920 8921 case "Users": 8922 if err := awsRestjson1_deserializeDocumentTraceUsers(&sv.Users, value); err != nil { 8923 return err 8924 } 8925 8926 default: 8927 _, _ = key, value 8928 8929 } 8930 } 8931 *v = sv 8932 return nil 8933} 8934 8935func awsRestjson1_deserializeDocumentTraceSummaryList(v *[]types.TraceSummary, value interface{}) error { 8936 if v == nil { 8937 return fmt.Errorf("unexpected nil of type %T", v) 8938 } 8939 if value == nil { 8940 return nil 8941 } 8942 8943 shape, ok := value.([]interface{}) 8944 if !ok { 8945 return fmt.Errorf("unexpected JSON type %v", value) 8946 } 8947 8948 var cv []types.TraceSummary 8949 if *v == nil { 8950 cv = []types.TraceSummary{} 8951 } else { 8952 cv = *v 8953 } 8954 8955 for _, value := range shape { 8956 var col types.TraceSummary 8957 destAddr := &col 8958 if err := awsRestjson1_deserializeDocumentTraceSummary(&destAddr, value); err != nil { 8959 return err 8960 } 8961 col = *destAddr 8962 cv = append(cv, col) 8963 8964 } 8965 *v = cv 8966 return nil 8967} 8968 8969func awsRestjson1_deserializeDocumentTraceUser(v **types.TraceUser, value interface{}) error { 8970 if v == nil { 8971 return fmt.Errorf("unexpected nil of type %T", v) 8972 } 8973 if value == nil { 8974 return nil 8975 } 8976 8977 shape, ok := value.(map[string]interface{}) 8978 if !ok { 8979 return fmt.Errorf("unexpected JSON type %v", value) 8980 } 8981 8982 var sv *types.TraceUser 8983 if *v == nil { 8984 sv = &types.TraceUser{} 8985 } else { 8986 sv = *v 8987 } 8988 8989 for key, value := range shape { 8990 switch key { 8991 case "ServiceIds": 8992 if err := awsRestjson1_deserializeDocumentServiceIds(&sv.ServiceIds, value); err != nil { 8993 return err 8994 } 8995 8996 case "UserName": 8997 if value != nil { 8998 jtv, ok := value.(string) 8999 if !ok { 9000 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9001 } 9002 sv.UserName = ptr.String(jtv) 9003 } 9004 9005 default: 9006 _, _ = key, value 9007 9008 } 9009 } 9010 *v = sv 9011 return nil 9012} 9013 9014func awsRestjson1_deserializeDocumentTraceUsers(v *[]types.TraceUser, value interface{}) error { 9015 if v == nil { 9016 return fmt.Errorf("unexpected nil of type %T", v) 9017 } 9018 if value == nil { 9019 return nil 9020 } 9021 9022 shape, ok := value.([]interface{}) 9023 if !ok { 9024 return fmt.Errorf("unexpected JSON type %v", value) 9025 } 9026 9027 var cv []types.TraceUser 9028 if *v == nil { 9029 cv = []types.TraceUser{} 9030 } else { 9031 cv = *v 9032 } 9033 9034 for _, value := range shape { 9035 var col types.TraceUser 9036 destAddr := &col 9037 if err := awsRestjson1_deserializeDocumentTraceUser(&destAddr, value); err != nil { 9038 return err 9039 } 9040 col = *destAddr 9041 cv = append(cv, col) 9042 9043 } 9044 *v = cv 9045 return nil 9046} 9047 9048func awsRestjson1_deserializeDocumentUnprocessedStatistics(v **types.UnprocessedStatistics, value interface{}) error { 9049 if v == nil { 9050 return fmt.Errorf("unexpected nil of type %T", v) 9051 } 9052 if value == nil { 9053 return nil 9054 } 9055 9056 shape, ok := value.(map[string]interface{}) 9057 if !ok { 9058 return fmt.Errorf("unexpected JSON type %v", value) 9059 } 9060 9061 var sv *types.UnprocessedStatistics 9062 if *v == nil { 9063 sv = &types.UnprocessedStatistics{} 9064 } else { 9065 sv = *v 9066 } 9067 9068 for key, value := range shape { 9069 switch key { 9070 case "ErrorCode": 9071 if value != nil { 9072 jtv, ok := value.(string) 9073 if !ok { 9074 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9075 } 9076 sv.ErrorCode = ptr.String(jtv) 9077 } 9078 9079 case "Message": 9080 if value != nil { 9081 jtv, ok := value.(string) 9082 if !ok { 9083 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9084 } 9085 sv.Message = ptr.String(jtv) 9086 } 9087 9088 case "RuleName": 9089 if value != nil { 9090 jtv, ok := value.(string) 9091 if !ok { 9092 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9093 } 9094 sv.RuleName = ptr.String(jtv) 9095 } 9096 9097 default: 9098 _, _ = key, value 9099 9100 } 9101 } 9102 *v = sv 9103 return nil 9104} 9105 9106func awsRestjson1_deserializeDocumentUnprocessedStatisticsList(v *[]types.UnprocessedStatistics, value interface{}) error { 9107 if v == nil { 9108 return fmt.Errorf("unexpected nil of type %T", v) 9109 } 9110 if value == nil { 9111 return nil 9112 } 9113 9114 shape, ok := value.([]interface{}) 9115 if !ok { 9116 return fmt.Errorf("unexpected JSON type %v", value) 9117 } 9118 9119 var cv []types.UnprocessedStatistics 9120 if *v == nil { 9121 cv = []types.UnprocessedStatistics{} 9122 } else { 9123 cv = *v 9124 } 9125 9126 for _, value := range shape { 9127 var col types.UnprocessedStatistics 9128 destAddr := &col 9129 if err := awsRestjson1_deserializeDocumentUnprocessedStatistics(&destAddr, value); err != nil { 9130 return err 9131 } 9132 col = *destAddr 9133 cv = append(cv, col) 9134 9135 } 9136 *v = cv 9137 return nil 9138} 9139 9140func awsRestjson1_deserializeDocumentUnprocessedTraceIdList(v *[]string, value interface{}) error { 9141 if v == nil { 9142 return fmt.Errorf("unexpected nil of type %T", v) 9143 } 9144 if value == nil { 9145 return nil 9146 } 9147 9148 shape, ok := value.([]interface{}) 9149 if !ok { 9150 return fmt.Errorf("unexpected JSON type %v", value) 9151 } 9152 9153 var cv []string 9154 if *v == nil { 9155 cv = []string{} 9156 } else { 9157 cv = *v 9158 } 9159 9160 for _, value := range shape { 9161 var col string 9162 if value != nil { 9163 jtv, ok := value.(string) 9164 if !ok { 9165 return fmt.Errorf("expected TraceId to be of type string, got %T instead", value) 9166 } 9167 col = jtv 9168 } 9169 cv = append(cv, col) 9170 9171 } 9172 *v = cv 9173 return nil 9174} 9175 9176func awsRestjson1_deserializeDocumentUnprocessedTraceSegment(v **types.UnprocessedTraceSegment, value interface{}) error { 9177 if v == nil { 9178 return fmt.Errorf("unexpected nil of type %T", v) 9179 } 9180 if value == nil { 9181 return nil 9182 } 9183 9184 shape, ok := value.(map[string]interface{}) 9185 if !ok { 9186 return fmt.Errorf("unexpected JSON type %v", value) 9187 } 9188 9189 var sv *types.UnprocessedTraceSegment 9190 if *v == nil { 9191 sv = &types.UnprocessedTraceSegment{} 9192 } else { 9193 sv = *v 9194 } 9195 9196 for key, value := range shape { 9197 switch key { 9198 case "ErrorCode": 9199 if value != nil { 9200 jtv, ok := value.(string) 9201 if !ok { 9202 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9203 } 9204 sv.ErrorCode = ptr.String(jtv) 9205 } 9206 9207 case "Id": 9208 if value != nil { 9209 jtv, ok := value.(string) 9210 if !ok { 9211 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9212 } 9213 sv.Id = ptr.String(jtv) 9214 } 9215 9216 case "Message": 9217 if value != nil { 9218 jtv, ok := value.(string) 9219 if !ok { 9220 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9221 } 9222 sv.Message = ptr.String(jtv) 9223 } 9224 9225 default: 9226 _, _ = key, value 9227 9228 } 9229 } 9230 *v = sv 9231 return nil 9232} 9233 9234func awsRestjson1_deserializeDocumentUnprocessedTraceSegmentList(v *[]types.UnprocessedTraceSegment, value interface{}) error { 9235 if v == nil { 9236 return fmt.Errorf("unexpected nil of type %T", v) 9237 } 9238 if value == nil { 9239 return nil 9240 } 9241 9242 shape, ok := value.([]interface{}) 9243 if !ok { 9244 return fmt.Errorf("unexpected JSON type %v", value) 9245 } 9246 9247 var cv []types.UnprocessedTraceSegment 9248 if *v == nil { 9249 cv = []types.UnprocessedTraceSegment{} 9250 } else { 9251 cv = *v 9252 } 9253 9254 for _, value := range shape { 9255 var col types.UnprocessedTraceSegment 9256 destAddr := &col 9257 if err := awsRestjson1_deserializeDocumentUnprocessedTraceSegment(&destAddr, value); err != nil { 9258 return err 9259 } 9260 col = *destAddr 9261 cv = append(cv, col) 9262 9263 } 9264 *v = cv 9265 return nil 9266} 9267 9268func awsRestjson1_deserializeDocumentValuesWithServiceIds(v *[]types.ValueWithServiceIds, value interface{}) error { 9269 if v == nil { 9270 return fmt.Errorf("unexpected nil of type %T", v) 9271 } 9272 if value == nil { 9273 return nil 9274 } 9275 9276 shape, ok := value.([]interface{}) 9277 if !ok { 9278 return fmt.Errorf("unexpected JSON type %v", value) 9279 } 9280 9281 var cv []types.ValueWithServiceIds 9282 if *v == nil { 9283 cv = []types.ValueWithServiceIds{} 9284 } else { 9285 cv = *v 9286 } 9287 9288 for _, value := range shape { 9289 var col types.ValueWithServiceIds 9290 destAddr := &col 9291 if err := awsRestjson1_deserializeDocumentValueWithServiceIds(&destAddr, value); err != nil { 9292 return err 9293 } 9294 col = *destAddr 9295 cv = append(cv, col) 9296 9297 } 9298 *v = cv 9299 return nil 9300} 9301 9302func awsRestjson1_deserializeDocumentValueWithServiceIds(v **types.ValueWithServiceIds, value interface{}) error { 9303 if v == nil { 9304 return fmt.Errorf("unexpected nil of type %T", v) 9305 } 9306 if value == nil { 9307 return nil 9308 } 9309 9310 shape, ok := value.(map[string]interface{}) 9311 if !ok { 9312 return fmt.Errorf("unexpected JSON type %v", value) 9313 } 9314 9315 var sv *types.ValueWithServiceIds 9316 if *v == nil { 9317 sv = &types.ValueWithServiceIds{} 9318 } else { 9319 sv = *v 9320 } 9321 9322 for key, value := range shape { 9323 switch key { 9324 case "AnnotationValue": 9325 if err := awsRestjson1_deserializeDocumentAnnotationValue(&sv.AnnotationValue, value); err != nil { 9326 return err 9327 } 9328 9329 case "ServiceIds": 9330 if err := awsRestjson1_deserializeDocumentServiceIds(&sv.ServiceIds, value); err != nil { 9331 return err 9332 } 9333 9334 default: 9335 _, _ = key, value 9336 9337 } 9338 } 9339 *v = sv 9340 return nil 9341} 9342