1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package guardduty 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/guardduty/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_deserializeOpAcceptInvitation struct { 23} 24 25func (*awsRestjson1_deserializeOpAcceptInvitation) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpAcceptInvitation) 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_deserializeOpErrorAcceptInvitation(response, &metadata) 44 } 45 output := &AcceptInvitationOutput{} 46 out.Result = output 47 48 return out, metadata, err 49} 50 51func awsRestjson1_deserializeOpErrorAcceptInvitation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 52 var errorBuffer bytes.Buffer 53 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 54 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 55 } 56 errorBody := bytes.NewReader(errorBuffer.Bytes()) 57 58 errorCode := "UnknownError" 59 errorMessage := errorCode 60 61 code := response.Header.Get("X-Amzn-ErrorType") 62 if len(code) != 0 { 63 errorCode = restjson.SanitizeErrorCode(code) 64 } 65 66 var buff [1024]byte 67 ringBuffer := smithyio.NewRingBuffer(buff[:]) 68 69 body := io.TeeReader(errorBody, ringBuffer) 70 decoder := json.NewDecoder(body) 71 decoder.UseNumber() 72 code, message, err := restjson.GetErrorInfo(decoder) 73 if err != nil { 74 var snapshot bytes.Buffer 75 io.Copy(&snapshot, ringBuffer) 76 err = &smithy.DeserializationError{ 77 Err: fmt.Errorf("failed to decode response body, %w", err), 78 Snapshot: snapshot.Bytes(), 79 } 80 return err 81 } 82 83 errorBody.Seek(0, io.SeekStart) 84 if len(code) != 0 { 85 errorCode = restjson.SanitizeErrorCode(code) 86 } 87 if len(message) != 0 { 88 errorMessage = message 89 } 90 91 switch { 92 case strings.EqualFold("BadRequestException", errorCode): 93 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 94 95 case strings.EqualFold("InternalServerErrorException", errorCode): 96 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 97 98 default: 99 genericError := &smithy.GenericAPIError{ 100 Code: errorCode, 101 Message: errorMessage, 102 } 103 return genericError 104 105 } 106} 107 108type awsRestjson1_deserializeOpArchiveFindings struct { 109} 110 111func (*awsRestjson1_deserializeOpArchiveFindings) ID() string { 112 return "OperationDeserializer" 113} 114 115func (m *awsRestjson1_deserializeOpArchiveFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 116 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 117) { 118 out, metadata, err = next.HandleDeserialize(ctx, in) 119 if err != nil { 120 return out, metadata, err 121 } 122 123 response, ok := out.RawResponse.(*smithyhttp.Response) 124 if !ok { 125 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 126 } 127 128 if response.StatusCode < 200 || response.StatusCode >= 300 { 129 return out, metadata, awsRestjson1_deserializeOpErrorArchiveFindings(response, &metadata) 130 } 131 output := &ArchiveFindingsOutput{} 132 out.Result = output 133 134 return out, metadata, err 135} 136 137func awsRestjson1_deserializeOpErrorArchiveFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 138 var errorBuffer bytes.Buffer 139 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 140 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 141 } 142 errorBody := bytes.NewReader(errorBuffer.Bytes()) 143 144 errorCode := "UnknownError" 145 errorMessage := errorCode 146 147 code := response.Header.Get("X-Amzn-ErrorType") 148 if len(code) != 0 { 149 errorCode = restjson.SanitizeErrorCode(code) 150 } 151 152 var buff [1024]byte 153 ringBuffer := smithyio.NewRingBuffer(buff[:]) 154 155 body := io.TeeReader(errorBody, ringBuffer) 156 decoder := json.NewDecoder(body) 157 decoder.UseNumber() 158 code, message, err := restjson.GetErrorInfo(decoder) 159 if err != nil { 160 var snapshot bytes.Buffer 161 io.Copy(&snapshot, ringBuffer) 162 err = &smithy.DeserializationError{ 163 Err: fmt.Errorf("failed to decode response body, %w", err), 164 Snapshot: snapshot.Bytes(), 165 } 166 return err 167 } 168 169 errorBody.Seek(0, io.SeekStart) 170 if len(code) != 0 { 171 errorCode = restjson.SanitizeErrorCode(code) 172 } 173 if len(message) != 0 { 174 errorMessage = message 175 } 176 177 switch { 178 case strings.EqualFold("BadRequestException", errorCode): 179 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 180 181 case strings.EqualFold("InternalServerErrorException", errorCode): 182 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 183 184 default: 185 genericError := &smithy.GenericAPIError{ 186 Code: errorCode, 187 Message: errorMessage, 188 } 189 return genericError 190 191 } 192} 193 194type awsRestjson1_deserializeOpCreateDetector struct { 195} 196 197func (*awsRestjson1_deserializeOpCreateDetector) ID() string { 198 return "OperationDeserializer" 199} 200 201func (m *awsRestjson1_deserializeOpCreateDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 202 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 203) { 204 out, metadata, err = next.HandleDeserialize(ctx, in) 205 if err != nil { 206 return out, metadata, err 207 } 208 209 response, ok := out.RawResponse.(*smithyhttp.Response) 210 if !ok { 211 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 212 } 213 214 if response.StatusCode < 200 || response.StatusCode >= 300 { 215 return out, metadata, awsRestjson1_deserializeOpErrorCreateDetector(response, &metadata) 216 } 217 output := &CreateDetectorOutput{} 218 out.Result = output 219 220 var buff [1024]byte 221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 222 223 body := io.TeeReader(response.Body, ringBuffer) 224 225 decoder := json.NewDecoder(body) 226 decoder.UseNumber() 227 var shape interface{} 228 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 229 var snapshot bytes.Buffer 230 io.Copy(&snapshot, ringBuffer) 231 err = &smithy.DeserializationError{ 232 Err: fmt.Errorf("failed to decode response body, %w", err), 233 Snapshot: snapshot.Bytes(), 234 } 235 return out, metadata, err 236 } 237 238 err = awsRestjson1_deserializeOpDocumentCreateDetectorOutput(&output, shape) 239 if err != nil { 240 var snapshot bytes.Buffer 241 io.Copy(&snapshot, ringBuffer) 242 return out, metadata, &smithy.DeserializationError{ 243 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 244 Snapshot: snapshot.Bytes(), 245 } 246 } 247 248 return out, metadata, err 249} 250 251func awsRestjson1_deserializeOpErrorCreateDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { 252 var errorBuffer bytes.Buffer 253 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 254 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 255 } 256 errorBody := bytes.NewReader(errorBuffer.Bytes()) 257 258 errorCode := "UnknownError" 259 errorMessage := errorCode 260 261 code := response.Header.Get("X-Amzn-ErrorType") 262 if len(code) != 0 { 263 errorCode = restjson.SanitizeErrorCode(code) 264 } 265 266 var buff [1024]byte 267 ringBuffer := smithyio.NewRingBuffer(buff[:]) 268 269 body := io.TeeReader(errorBody, ringBuffer) 270 decoder := json.NewDecoder(body) 271 decoder.UseNumber() 272 code, message, err := restjson.GetErrorInfo(decoder) 273 if err != nil { 274 var snapshot bytes.Buffer 275 io.Copy(&snapshot, ringBuffer) 276 err = &smithy.DeserializationError{ 277 Err: fmt.Errorf("failed to decode response body, %w", err), 278 Snapshot: snapshot.Bytes(), 279 } 280 return err 281 } 282 283 errorBody.Seek(0, io.SeekStart) 284 if len(code) != 0 { 285 errorCode = restjson.SanitizeErrorCode(code) 286 } 287 if len(message) != 0 { 288 errorMessage = message 289 } 290 291 switch { 292 case strings.EqualFold("BadRequestException", errorCode): 293 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 294 295 case strings.EqualFold("InternalServerErrorException", errorCode): 296 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 297 298 default: 299 genericError := &smithy.GenericAPIError{ 300 Code: errorCode, 301 Message: errorMessage, 302 } 303 return genericError 304 305 } 306} 307 308func awsRestjson1_deserializeOpDocumentCreateDetectorOutput(v **CreateDetectorOutput, value interface{}) error { 309 if v == nil { 310 return fmt.Errorf("unexpected nil of type %T", v) 311 } 312 if value == nil { 313 return nil 314 } 315 316 shape, ok := value.(map[string]interface{}) 317 if !ok { 318 return fmt.Errorf("unexpected JSON type %v", value) 319 } 320 321 var sv *CreateDetectorOutput 322 if *v == nil { 323 sv = &CreateDetectorOutput{} 324 } else { 325 sv = *v 326 } 327 328 for key, value := range shape { 329 switch key { 330 case "detectorId": 331 if value != nil { 332 jtv, ok := value.(string) 333 if !ok { 334 return fmt.Errorf("expected DetectorId to be of type string, got %T instead", value) 335 } 336 sv.DetectorId = ptr.String(jtv) 337 } 338 339 default: 340 _, _ = key, value 341 342 } 343 } 344 *v = sv 345 return nil 346} 347 348type awsRestjson1_deserializeOpCreateFilter struct { 349} 350 351func (*awsRestjson1_deserializeOpCreateFilter) ID() string { 352 return "OperationDeserializer" 353} 354 355func (m *awsRestjson1_deserializeOpCreateFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 356 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 357) { 358 out, metadata, err = next.HandleDeserialize(ctx, in) 359 if err != nil { 360 return out, metadata, err 361 } 362 363 response, ok := out.RawResponse.(*smithyhttp.Response) 364 if !ok { 365 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 366 } 367 368 if response.StatusCode < 200 || response.StatusCode >= 300 { 369 return out, metadata, awsRestjson1_deserializeOpErrorCreateFilter(response, &metadata) 370 } 371 output := &CreateFilterOutput{} 372 out.Result = output 373 374 var buff [1024]byte 375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 376 377 body := io.TeeReader(response.Body, ringBuffer) 378 379 decoder := json.NewDecoder(body) 380 decoder.UseNumber() 381 var shape interface{} 382 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 383 var snapshot bytes.Buffer 384 io.Copy(&snapshot, ringBuffer) 385 err = &smithy.DeserializationError{ 386 Err: fmt.Errorf("failed to decode response body, %w", err), 387 Snapshot: snapshot.Bytes(), 388 } 389 return out, metadata, err 390 } 391 392 err = awsRestjson1_deserializeOpDocumentCreateFilterOutput(&output, shape) 393 if err != nil { 394 var snapshot bytes.Buffer 395 io.Copy(&snapshot, ringBuffer) 396 return out, metadata, &smithy.DeserializationError{ 397 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 398 Snapshot: snapshot.Bytes(), 399 } 400 } 401 402 return out, metadata, err 403} 404 405func awsRestjson1_deserializeOpErrorCreateFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 406 var errorBuffer bytes.Buffer 407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 409 } 410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 411 412 errorCode := "UnknownError" 413 errorMessage := errorCode 414 415 code := response.Header.Get("X-Amzn-ErrorType") 416 if len(code) != 0 { 417 errorCode = restjson.SanitizeErrorCode(code) 418 } 419 420 var buff [1024]byte 421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 422 423 body := io.TeeReader(errorBody, ringBuffer) 424 decoder := json.NewDecoder(body) 425 decoder.UseNumber() 426 code, message, err := restjson.GetErrorInfo(decoder) 427 if err != nil { 428 var snapshot bytes.Buffer 429 io.Copy(&snapshot, ringBuffer) 430 err = &smithy.DeserializationError{ 431 Err: fmt.Errorf("failed to decode response body, %w", err), 432 Snapshot: snapshot.Bytes(), 433 } 434 return err 435 } 436 437 errorBody.Seek(0, io.SeekStart) 438 if len(code) != 0 { 439 errorCode = restjson.SanitizeErrorCode(code) 440 } 441 if len(message) != 0 { 442 errorMessage = message 443 } 444 445 switch { 446 case strings.EqualFold("BadRequestException", errorCode): 447 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 448 449 case strings.EqualFold("InternalServerErrorException", errorCode): 450 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 451 452 default: 453 genericError := &smithy.GenericAPIError{ 454 Code: errorCode, 455 Message: errorMessage, 456 } 457 return genericError 458 459 } 460} 461 462func awsRestjson1_deserializeOpDocumentCreateFilterOutput(v **CreateFilterOutput, value interface{}) error { 463 if v == nil { 464 return fmt.Errorf("unexpected nil of type %T", v) 465 } 466 if value == nil { 467 return nil 468 } 469 470 shape, ok := value.(map[string]interface{}) 471 if !ok { 472 return fmt.Errorf("unexpected JSON type %v", value) 473 } 474 475 var sv *CreateFilterOutput 476 if *v == nil { 477 sv = &CreateFilterOutput{} 478 } else { 479 sv = *v 480 } 481 482 for key, value := range shape { 483 switch key { 484 case "name": 485 if value != nil { 486 jtv, ok := value.(string) 487 if !ok { 488 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 489 } 490 sv.Name = ptr.String(jtv) 491 } 492 493 default: 494 _, _ = key, value 495 496 } 497 } 498 *v = sv 499 return nil 500} 501 502type awsRestjson1_deserializeOpCreateIPSet struct { 503} 504 505func (*awsRestjson1_deserializeOpCreateIPSet) ID() string { 506 return "OperationDeserializer" 507} 508 509func (m *awsRestjson1_deserializeOpCreateIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 510 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 511) { 512 out, metadata, err = next.HandleDeserialize(ctx, in) 513 if err != nil { 514 return out, metadata, err 515 } 516 517 response, ok := out.RawResponse.(*smithyhttp.Response) 518 if !ok { 519 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 520 } 521 522 if response.StatusCode < 200 || response.StatusCode >= 300 { 523 return out, metadata, awsRestjson1_deserializeOpErrorCreateIPSet(response, &metadata) 524 } 525 output := &CreateIPSetOutput{} 526 out.Result = output 527 528 var buff [1024]byte 529 ringBuffer := smithyio.NewRingBuffer(buff[:]) 530 531 body := io.TeeReader(response.Body, ringBuffer) 532 533 decoder := json.NewDecoder(body) 534 decoder.UseNumber() 535 var shape interface{} 536 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 537 var snapshot bytes.Buffer 538 io.Copy(&snapshot, ringBuffer) 539 err = &smithy.DeserializationError{ 540 Err: fmt.Errorf("failed to decode response body, %w", err), 541 Snapshot: snapshot.Bytes(), 542 } 543 return out, metadata, err 544 } 545 546 err = awsRestjson1_deserializeOpDocumentCreateIPSetOutput(&output, shape) 547 if err != nil { 548 var snapshot bytes.Buffer 549 io.Copy(&snapshot, ringBuffer) 550 return out, metadata, &smithy.DeserializationError{ 551 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 552 Snapshot: snapshot.Bytes(), 553 } 554 } 555 556 return out, metadata, err 557} 558 559func awsRestjson1_deserializeOpErrorCreateIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 560 var errorBuffer bytes.Buffer 561 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 562 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 563 } 564 errorBody := bytes.NewReader(errorBuffer.Bytes()) 565 566 errorCode := "UnknownError" 567 errorMessage := errorCode 568 569 code := response.Header.Get("X-Amzn-ErrorType") 570 if len(code) != 0 { 571 errorCode = restjson.SanitizeErrorCode(code) 572 } 573 574 var buff [1024]byte 575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 576 577 body := io.TeeReader(errorBody, ringBuffer) 578 decoder := json.NewDecoder(body) 579 decoder.UseNumber() 580 code, message, err := restjson.GetErrorInfo(decoder) 581 if err != nil { 582 var snapshot bytes.Buffer 583 io.Copy(&snapshot, ringBuffer) 584 err = &smithy.DeserializationError{ 585 Err: fmt.Errorf("failed to decode response body, %w", err), 586 Snapshot: snapshot.Bytes(), 587 } 588 return err 589 } 590 591 errorBody.Seek(0, io.SeekStart) 592 if len(code) != 0 { 593 errorCode = restjson.SanitizeErrorCode(code) 594 } 595 if len(message) != 0 { 596 errorMessage = message 597 } 598 599 switch { 600 case strings.EqualFold("BadRequestException", errorCode): 601 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 602 603 case strings.EqualFold("InternalServerErrorException", errorCode): 604 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 605 606 default: 607 genericError := &smithy.GenericAPIError{ 608 Code: errorCode, 609 Message: errorMessage, 610 } 611 return genericError 612 613 } 614} 615 616func awsRestjson1_deserializeOpDocumentCreateIPSetOutput(v **CreateIPSetOutput, value interface{}) error { 617 if v == nil { 618 return fmt.Errorf("unexpected nil of type %T", v) 619 } 620 if value == nil { 621 return nil 622 } 623 624 shape, ok := value.(map[string]interface{}) 625 if !ok { 626 return fmt.Errorf("unexpected JSON type %v", value) 627 } 628 629 var sv *CreateIPSetOutput 630 if *v == nil { 631 sv = &CreateIPSetOutput{} 632 } else { 633 sv = *v 634 } 635 636 for key, value := range shape { 637 switch key { 638 case "ipSetId": 639 if value != nil { 640 jtv, ok := value.(string) 641 if !ok { 642 return fmt.Errorf("expected String to be of type string, got %T instead", value) 643 } 644 sv.IpSetId = ptr.String(jtv) 645 } 646 647 default: 648 _, _ = key, value 649 650 } 651 } 652 *v = sv 653 return nil 654} 655 656type awsRestjson1_deserializeOpCreateMembers struct { 657} 658 659func (*awsRestjson1_deserializeOpCreateMembers) ID() string { 660 return "OperationDeserializer" 661} 662 663func (m *awsRestjson1_deserializeOpCreateMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 664 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 665) { 666 out, metadata, err = next.HandleDeserialize(ctx, in) 667 if err != nil { 668 return out, metadata, err 669 } 670 671 response, ok := out.RawResponse.(*smithyhttp.Response) 672 if !ok { 673 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 674 } 675 676 if response.StatusCode < 200 || response.StatusCode >= 300 { 677 return out, metadata, awsRestjson1_deserializeOpErrorCreateMembers(response, &metadata) 678 } 679 output := &CreateMembersOutput{} 680 out.Result = output 681 682 var buff [1024]byte 683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 684 685 body := io.TeeReader(response.Body, ringBuffer) 686 687 decoder := json.NewDecoder(body) 688 decoder.UseNumber() 689 var shape interface{} 690 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 691 var snapshot bytes.Buffer 692 io.Copy(&snapshot, ringBuffer) 693 err = &smithy.DeserializationError{ 694 Err: fmt.Errorf("failed to decode response body, %w", err), 695 Snapshot: snapshot.Bytes(), 696 } 697 return out, metadata, err 698 } 699 700 err = awsRestjson1_deserializeOpDocumentCreateMembersOutput(&output, shape) 701 if err != nil { 702 var snapshot bytes.Buffer 703 io.Copy(&snapshot, ringBuffer) 704 return out, metadata, &smithy.DeserializationError{ 705 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 706 Snapshot: snapshot.Bytes(), 707 } 708 } 709 710 return out, metadata, err 711} 712 713func awsRestjson1_deserializeOpErrorCreateMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 714 var errorBuffer bytes.Buffer 715 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 716 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 717 } 718 errorBody := bytes.NewReader(errorBuffer.Bytes()) 719 720 errorCode := "UnknownError" 721 errorMessage := errorCode 722 723 code := response.Header.Get("X-Amzn-ErrorType") 724 if len(code) != 0 { 725 errorCode = restjson.SanitizeErrorCode(code) 726 } 727 728 var buff [1024]byte 729 ringBuffer := smithyio.NewRingBuffer(buff[:]) 730 731 body := io.TeeReader(errorBody, ringBuffer) 732 decoder := json.NewDecoder(body) 733 decoder.UseNumber() 734 code, message, err := restjson.GetErrorInfo(decoder) 735 if err != nil { 736 var snapshot bytes.Buffer 737 io.Copy(&snapshot, ringBuffer) 738 err = &smithy.DeserializationError{ 739 Err: fmt.Errorf("failed to decode response body, %w", err), 740 Snapshot: snapshot.Bytes(), 741 } 742 return err 743 } 744 745 errorBody.Seek(0, io.SeekStart) 746 if len(code) != 0 { 747 errorCode = restjson.SanitizeErrorCode(code) 748 } 749 if len(message) != 0 { 750 errorMessage = message 751 } 752 753 switch { 754 case strings.EqualFold("BadRequestException", errorCode): 755 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 756 757 case strings.EqualFold("InternalServerErrorException", errorCode): 758 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 759 760 default: 761 genericError := &smithy.GenericAPIError{ 762 Code: errorCode, 763 Message: errorMessage, 764 } 765 return genericError 766 767 } 768} 769 770func awsRestjson1_deserializeOpDocumentCreateMembersOutput(v **CreateMembersOutput, value interface{}) error { 771 if v == nil { 772 return fmt.Errorf("unexpected nil of type %T", v) 773 } 774 if value == nil { 775 return nil 776 } 777 778 shape, ok := value.(map[string]interface{}) 779 if !ok { 780 return fmt.Errorf("unexpected JSON type %v", value) 781 } 782 783 var sv *CreateMembersOutput 784 if *v == nil { 785 sv = &CreateMembersOutput{} 786 } else { 787 sv = *v 788 } 789 790 for key, value := range shape { 791 switch key { 792 case "unprocessedAccounts": 793 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 794 return err 795 } 796 797 default: 798 _, _ = key, value 799 800 } 801 } 802 *v = sv 803 return nil 804} 805 806type awsRestjson1_deserializeOpCreatePublishingDestination struct { 807} 808 809func (*awsRestjson1_deserializeOpCreatePublishingDestination) ID() string { 810 return "OperationDeserializer" 811} 812 813func (m *awsRestjson1_deserializeOpCreatePublishingDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 814 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 815) { 816 out, metadata, err = next.HandleDeserialize(ctx, in) 817 if err != nil { 818 return out, metadata, err 819 } 820 821 response, ok := out.RawResponse.(*smithyhttp.Response) 822 if !ok { 823 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 824 } 825 826 if response.StatusCode < 200 || response.StatusCode >= 300 { 827 return out, metadata, awsRestjson1_deserializeOpErrorCreatePublishingDestination(response, &metadata) 828 } 829 output := &CreatePublishingDestinationOutput{} 830 out.Result = output 831 832 var buff [1024]byte 833 ringBuffer := smithyio.NewRingBuffer(buff[:]) 834 835 body := io.TeeReader(response.Body, ringBuffer) 836 837 decoder := json.NewDecoder(body) 838 decoder.UseNumber() 839 var shape interface{} 840 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 841 var snapshot bytes.Buffer 842 io.Copy(&snapshot, ringBuffer) 843 err = &smithy.DeserializationError{ 844 Err: fmt.Errorf("failed to decode response body, %w", err), 845 Snapshot: snapshot.Bytes(), 846 } 847 return out, metadata, err 848 } 849 850 err = awsRestjson1_deserializeOpDocumentCreatePublishingDestinationOutput(&output, shape) 851 if err != nil { 852 var snapshot bytes.Buffer 853 io.Copy(&snapshot, ringBuffer) 854 return out, metadata, &smithy.DeserializationError{ 855 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 856 Snapshot: snapshot.Bytes(), 857 } 858 } 859 860 return out, metadata, err 861} 862 863func awsRestjson1_deserializeOpErrorCreatePublishingDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 864 var errorBuffer bytes.Buffer 865 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 866 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 867 } 868 errorBody := bytes.NewReader(errorBuffer.Bytes()) 869 870 errorCode := "UnknownError" 871 errorMessage := errorCode 872 873 code := response.Header.Get("X-Amzn-ErrorType") 874 if len(code) != 0 { 875 errorCode = restjson.SanitizeErrorCode(code) 876 } 877 878 var buff [1024]byte 879 ringBuffer := smithyio.NewRingBuffer(buff[:]) 880 881 body := io.TeeReader(errorBody, ringBuffer) 882 decoder := json.NewDecoder(body) 883 decoder.UseNumber() 884 code, message, err := restjson.GetErrorInfo(decoder) 885 if err != nil { 886 var snapshot bytes.Buffer 887 io.Copy(&snapshot, ringBuffer) 888 err = &smithy.DeserializationError{ 889 Err: fmt.Errorf("failed to decode response body, %w", err), 890 Snapshot: snapshot.Bytes(), 891 } 892 return err 893 } 894 895 errorBody.Seek(0, io.SeekStart) 896 if len(code) != 0 { 897 errorCode = restjson.SanitizeErrorCode(code) 898 } 899 if len(message) != 0 { 900 errorMessage = message 901 } 902 903 switch { 904 case strings.EqualFold("BadRequestException", errorCode): 905 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 906 907 case strings.EqualFold("InternalServerErrorException", errorCode): 908 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 909 910 default: 911 genericError := &smithy.GenericAPIError{ 912 Code: errorCode, 913 Message: errorMessage, 914 } 915 return genericError 916 917 } 918} 919 920func awsRestjson1_deserializeOpDocumentCreatePublishingDestinationOutput(v **CreatePublishingDestinationOutput, value interface{}) error { 921 if v == nil { 922 return fmt.Errorf("unexpected nil of type %T", v) 923 } 924 if value == nil { 925 return nil 926 } 927 928 shape, ok := value.(map[string]interface{}) 929 if !ok { 930 return fmt.Errorf("unexpected JSON type %v", value) 931 } 932 933 var sv *CreatePublishingDestinationOutput 934 if *v == nil { 935 sv = &CreatePublishingDestinationOutput{} 936 } else { 937 sv = *v 938 } 939 940 for key, value := range shape { 941 switch key { 942 case "destinationId": 943 if value != nil { 944 jtv, ok := value.(string) 945 if !ok { 946 return fmt.Errorf("expected String to be of type string, got %T instead", value) 947 } 948 sv.DestinationId = ptr.String(jtv) 949 } 950 951 default: 952 _, _ = key, value 953 954 } 955 } 956 *v = sv 957 return nil 958} 959 960type awsRestjson1_deserializeOpCreateSampleFindings struct { 961} 962 963func (*awsRestjson1_deserializeOpCreateSampleFindings) ID() string { 964 return "OperationDeserializer" 965} 966 967func (m *awsRestjson1_deserializeOpCreateSampleFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 968 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 969) { 970 out, metadata, err = next.HandleDeserialize(ctx, in) 971 if err != nil { 972 return out, metadata, err 973 } 974 975 response, ok := out.RawResponse.(*smithyhttp.Response) 976 if !ok { 977 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 978 } 979 980 if response.StatusCode < 200 || response.StatusCode >= 300 { 981 return out, metadata, awsRestjson1_deserializeOpErrorCreateSampleFindings(response, &metadata) 982 } 983 output := &CreateSampleFindingsOutput{} 984 out.Result = output 985 986 return out, metadata, err 987} 988 989func awsRestjson1_deserializeOpErrorCreateSampleFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 990 var errorBuffer bytes.Buffer 991 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 992 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 993 } 994 errorBody := bytes.NewReader(errorBuffer.Bytes()) 995 996 errorCode := "UnknownError" 997 errorMessage := errorCode 998 999 code := response.Header.Get("X-Amzn-ErrorType") 1000 if len(code) != 0 { 1001 errorCode = restjson.SanitizeErrorCode(code) 1002 } 1003 1004 var buff [1024]byte 1005 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1006 1007 body := io.TeeReader(errorBody, ringBuffer) 1008 decoder := json.NewDecoder(body) 1009 decoder.UseNumber() 1010 code, message, err := restjson.GetErrorInfo(decoder) 1011 if err != nil { 1012 var snapshot bytes.Buffer 1013 io.Copy(&snapshot, ringBuffer) 1014 err = &smithy.DeserializationError{ 1015 Err: fmt.Errorf("failed to decode response body, %w", err), 1016 Snapshot: snapshot.Bytes(), 1017 } 1018 return err 1019 } 1020 1021 errorBody.Seek(0, io.SeekStart) 1022 if len(code) != 0 { 1023 errorCode = restjson.SanitizeErrorCode(code) 1024 } 1025 if len(message) != 0 { 1026 errorMessage = message 1027 } 1028 1029 switch { 1030 case strings.EqualFold("BadRequestException", errorCode): 1031 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1032 1033 case strings.EqualFold("InternalServerErrorException", errorCode): 1034 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1035 1036 default: 1037 genericError := &smithy.GenericAPIError{ 1038 Code: errorCode, 1039 Message: errorMessage, 1040 } 1041 return genericError 1042 1043 } 1044} 1045 1046type awsRestjson1_deserializeOpCreateThreatIntelSet struct { 1047} 1048 1049func (*awsRestjson1_deserializeOpCreateThreatIntelSet) ID() string { 1050 return "OperationDeserializer" 1051} 1052 1053func (m *awsRestjson1_deserializeOpCreateThreatIntelSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1054 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1055) { 1056 out, metadata, err = next.HandleDeserialize(ctx, in) 1057 if err != nil { 1058 return out, metadata, err 1059 } 1060 1061 response, ok := out.RawResponse.(*smithyhttp.Response) 1062 if !ok { 1063 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1064 } 1065 1066 if response.StatusCode < 200 || response.StatusCode >= 300 { 1067 return out, metadata, awsRestjson1_deserializeOpErrorCreateThreatIntelSet(response, &metadata) 1068 } 1069 output := &CreateThreatIntelSetOutput{} 1070 out.Result = output 1071 1072 var buff [1024]byte 1073 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1074 1075 body := io.TeeReader(response.Body, ringBuffer) 1076 1077 decoder := json.NewDecoder(body) 1078 decoder.UseNumber() 1079 var shape interface{} 1080 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1081 var snapshot bytes.Buffer 1082 io.Copy(&snapshot, ringBuffer) 1083 err = &smithy.DeserializationError{ 1084 Err: fmt.Errorf("failed to decode response body, %w", err), 1085 Snapshot: snapshot.Bytes(), 1086 } 1087 return out, metadata, err 1088 } 1089 1090 err = awsRestjson1_deserializeOpDocumentCreateThreatIntelSetOutput(&output, shape) 1091 if err != nil { 1092 var snapshot bytes.Buffer 1093 io.Copy(&snapshot, ringBuffer) 1094 return out, metadata, &smithy.DeserializationError{ 1095 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1096 Snapshot: snapshot.Bytes(), 1097 } 1098 } 1099 1100 return out, metadata, err 1101} 1102 1103func awsRestjson1_deserializeOpErrorCreateThreatIntelSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1104 var errorBuffer bytes.Buffer 1105 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1106 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1107 } 1108 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1109 1110 errorCode := "UnknownError" 1111 errorMessage := errorCode 1112 1113 code := response.Header.Get("X-Amzn-ErrorType") 1114 if len(code) != 0 { 1115 errorCode = restjson.SanitizeErrorCode(code) 1116 } 1117 1118 var buff [1024]byte 1119 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1120 1121 body := io.TeeReader(errorBody, ringBuffer) 1122 decoder := json.NewDecoder(body) 1123 decoder.UseNumber() 1124 code, message, err := restjson.GetErrorInfo(decoder) 1125 if err != nil { 1126 var snapshot bytes.Buffer 1127 io.Copy(&snapshot, ringBuffer) 1128 err = &smithy.DeserializationError{ 1129 Err: fmt.Errorf("failed to decode response body, %w", err), 1130 Snapshot: snapshot.Bytes(), 1131 } 1132 return err 1133 } 1134 1135 errorBody.Seek(0, io.SeekStart) 1136 if len(code) != 0 { 1137 errorCode = restjson.SanitizeErrorCode(code) 1138 } 1139 if len(message) != 0 { 1140 errorMessage = message 1141 } 1142 1143 switch { 1144 case strings.EqualFold("BadRequestException", errorCode): 1145 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1146 1147 case strings.EqualFold("InternalServerErrorException", errorCode): 1148 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1149 1150 default: 1151 genericError := &smithy.GenericAPIError{ 1152 Code: errorCode, 1153 Message: errorMessage, 1154 } 1155 return genericError 1156 1157 } 1158} 1159 1160func awsRestjson1_deserializeOpDocumentCreateThreatIntelSetOutput(v **CreateThreatIntelSetOutput, value interface{}) error { 1161 if v == nil { 1162 return fmt.Errorf("unexpected nil of type %T", v) 1163 } 1164 if value == nil { 1165 return nil 1166 } 1167 1168 shape, ok := value.(map[string]interface{}) 1169 if !ok { 1170 return fmt.Errorf("unexpected JSON type %v", value) 1171 } 1172 1173 var sv *CreateThreatIntelSetOutput 1174 if *v == nil { 1175 sv = &CreateThreatIntelSetOutput{} 1176 } else { 1177 sv = *v 1178 } 1179 1180 for key, value := range shape { 1181 switch key { 1182 case "threatIntelSetId": 1183 if value != nil { 1184 jtv, ok := value.(string) 1185 if !ok { 1186 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1187 } 1188 sv.ThreatIntelSetId = ptr.String(jtv) 1189 } 1190 1191 default: 1192 _, _ = key, value 1193 1194 } 1195 } 1196 *v = sv 1197 return nil 1198} 1199 1200type awsRestjson1_deserializeOpDeclineInvitations struct { 1201} 1202 1203func (*awsRestjson1_deserializeOpDeclineInvitations) ID() string { 1204 return "OperationDeserializer" 1205} 1206 1207func (m *awsRestjson1_deserializeOpDeclineInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1208 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1209) { 1210 out, metadata, err = next.HandleDeserialize(ctx, in) 1211 if err != nil { 1212 return out, metadata, err 1213 } 1214 1215 response, ok := out.RawResponse.(*smithyhttp.Response) 1216 if !ok { 1217 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1218 } 1219 1220 if response.StatusCode < 200 || response.StatusCode >= 300 { 1221 return out, metadata, awsRestjson1_deserializeOpErrorDeclineInvitations(response, &metadata) 1222 } 1223 output := &DeclineInvitationsOutput{} 1224 out.Result = output 1225 1226 var buff [1024]byte 1227 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1228 1229 body := io.TeeReader(response.Body, ringBuffer) 1230 1231 decoder := json.NewDecoder(body) 1232 decoder.UseNumber() 1233 var shape interface{} 1234 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1235 var snapshot bytes.Buffer 1236 io.Copy(&snapshot, ringBuffer) 1237 err = &smithy.DeserializationError{ 1238 Err: fmt.Errorf("failed to decode response body, %w", err), 1239 Snapshot: snapshot.Bytes(), 1240 } 1241 return out, metadata, err 1242 } 1243 1244 err = awsRestjson1_deserializeOpDocumentDeclineInvitationsOutput(&output, shape) 1245 if err != nil { 1246 var snapshot bytes.Buffer 1247 io.Copy(&snapshot, ringBuffer) 1248 return out, metadata, &smithy.DeserializationError{ 1249 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1250 Snapshot: snapshot.Bytes(), 1251 } 1252 } 1253 1254 return out, metadata, err 1255} 1256 1257func awsRestjson1_deserializeOpErrorDeclineInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1258 var errorBuffer bytes.Buffer 1259 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1260 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1261 } 1262 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1263 1264 errorCode := "UnknownError" 1265 errorMessage := errorCode 1266 1267 code := response.Header.Get("X-Amzn-ErrorType") 1268 if len(code) != 0 { 1269 errorCode = restjson.SanitizeErrorCode(code) 1270 } 1271 1272 var buff [1024]byte 1273 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1274 1275 body := io.TeeReader(errorBody, ringBuffer) 1276 decoder := json.NewDecoder(body) 1277 decoder.UseNumber() 1278 code, message, err := restjson.GetErrorInfo(decoder) 1279 if err != nil { 1280 var snapshot bytes.Buffer 1281 io.Copy(&snapshot, ringBuffer) 1282 err = &smithy.DeserializationError{ 1283 Err: fmt.Errorf("failed to decode response body, %w", err), 1284 Snapshot: snapshot.Bytes(), 1285 } 1286 return err 1287 } 1288 1289 errorBody.Seek(0, io.SeekStart) 1290 if len(code) != 0 { 1291 errorCode = restjson.SanitizeErrorCode(code) 1292 } 1293 if len(message) != 0 { 1294 errorMessage = message 1295 } 1296 1297 switch { 1298 case strings.EqualFold("BadRequestException", errorCode): 1299 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1300 1301 case strings.EqualFold("InternalServerErrorException", errorCode): 1302 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1303 1304 default: 1305 genericError := &smithy.GenericAPIError{ 1306 Code: errorCode, 1307 Message: errorMessage, 1308 } 1309 return genericError 1310 1311 } 1312} 1313 1314func awsRestjson1_deserializeOpDocumentDeclineInvitationsOutput(v **DeclineInvitationsOutput, value interface{}) error { 1315 if v == nil { 1316 return fmt.Errorf("unexpected nil of type %T", v) 1317 } 1318 if value == nil { 1319 return nil 1320 } 1321 1322 shape, ok := value.(map[string]interface{}) 1323 if !ok { 1324 return fmt.Errorf("unexpected JSON type %v", value) 1325 } 1326 1327 var sv *DeclineInvitationsOutput 1328 if *v == nil { 1329 sv = &DeclineInvitationsOutput{} 1330 } else { 1331 sv = *v 1332 } 1333 1334 for key, value := range shape { 1335 switch key { 1336 case "unprocessedAccounts": 1337 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 1338 return err 1339 } 1340 1341 default: 1342 _, _ = key, value 1343 1344 } 1345 } 1346 *v = sv 1347 return nil 1348} 1349 1350type awsRestjson1_deserializeOpDeleteDetector struct { 1351} 1352 1353func (*awsRestjson1_deserializeOpDeleteDetector) ID() string { 1354 return "OperationDeserializer" 1355} 1356 1357func (m *awsRestjson1_deserializeOpDeleteDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1358 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1359) { 1360 out, metadata, err = next.HandleDeserialize(ctx, in) 1361 if err != nil { 1362 return out, metadata, err 1363 } 1364 1365 response, ok := out.RawResponse.(*smithyhttp.Response) 1366 if !ok { 1367 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1368 } 1369 1370 if response.StatusCode < 200 || response.StatusCode >= 300 { 1371 return out, metadata, awsRestjson1_deserializeOpErrorDeleteDetector(response, &metadata) 1372 } 1373 output := &DeleteDetectorOutput{} 1374 out.Result = output 1375 1376 return out, metadata, err 1377} 1378 1379func awsRestjson1_deserializeOpErrorDeleteDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1380 var errorBuffer bytes.Buffer 1381 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1382 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1383 } 1384 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1385 1386 errorCode := "UnknownError" 1387 errorMessage := errorCode 1388 1389 code := response.Header.Get("X-Amzn-ErrorType") 1390 if len(code) != 0 { 1391 errorCode = restjson.SanitizeErrorCode(code) 1392 } 1393 1394 var buff [1024]byte 1395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1396 1397 body := io.TeeReader(errorBody, ringBuffer) 1398 decoder := json.NewDecoder(body) 1399 decoder.UseNumber() 1400 code, message, err := restjson.GetErrorInfo(decoder) 1401 if err != nil { 1402 var snapshot bytes.Buffer 1403 io.Copy(&snapshot, ringBuffer) 1404 err = &smithy.DeserializationError{ 1405 Err: fmt.Errorf("failed to decode response body, %w", err), 1406 Snapshot: snapshot.Bytes(), 1407 } 1408 return err 1409 } 1410 1411 errorBody.Seek(0, io.SeekStart) 1412 if len(code) != 0 { 1413 errorCode = restjson.SanitizeErrorCode(code) 1414 } 1415 if len(message) != 0 { 1416 errorMessage = message 1417 } 1418 1419 switch { 1420 case strings.EqualFold("BadRequestException", errorCode): 1421 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1422 1423 case strings.EqualFold("InternalServerErrorException", errorCode): 1424 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1425 1426 default: 1427 genericError := &smithy.GenericAPIError{ 1428 Code: errorCode, 1429 Message: errorMessage, 1430 } 1431 return genericError 1432 1433 } 1434} 1435 1436type awsRestjson1_deserializeOpDeleteFilter struct { 1437} 1438 1439func (*awsRestjson1_deserializeOpDeleteFilter) ID() string { 1440 return "OperationDeserializer" 1441} 1442 1443func (m *awsRestjson1_deserializeOpDeleteFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1444 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1445) { 1446 out, metadata, err = next.HandleDeserialize(ctx, in) 1447 if err != nil { 1448 return out, metadata, err 1449 } 1450 1451 response, ok := out.RawResponse.(*smithyhttp.Response) 1452 if !ok { 1453 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1454 } 1455 1456 if response.StatusCode < 200 || response.StatusCode >= 300 { 1457 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFilter(response, &metadata) 1458 } 1459 output := &DeleteFilterOutput{} 1460 out.Result = output 1461 1462 return out, metadata, err 1463} 1464 1465func awsRestjson1_deserializeOpErrorDeleteFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1466 var errorBuffer bytes.Buffer 1467 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1468 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1469 } 1470 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1471 1472 errorCode := "UnknownError" 1473 errorMessage := errorCode 1474 1475 code := response.Header.Get("X-Amzn-ErrorType") 1476 if len(code) != 0 { 1477 errorCode = restjson.SanitizeErrorCode(code) 1478 } 1479 1480 var buff [1024]byte 1481 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1482 1483 body := io.TeeReader(errorBody, ringBuffer) 1484 decoder := json.NewDecoder(body) 1485 decoder.UseNumber() 1486 code, message, err := restjson.GetErrorInfo(decoder) 1487 if err != nil { 1488 var snapshot bytes.Buffer 1489 io.Copy(&snapshot, ringBuffer) 1490 err = &smithy.DeserializationError{ 1491 Err: fmt.Errorf("failed to decode response body, %w", err), 1492 Snapshot: snapshot.Bytes(), 1493 } 1494 return err 1495 } 1496 1497 errorBody.Seek(0, io.SeekStart) 1498 if len(code) != 0 { 1499 errorCode = restjson.SanitizeErrorCode(code) 1500 } 1501 if len(message) != 0 { 1502 errorMessage = message 1503 } 1504 1505 switch { 1506 case strings.EqualFold("BadRequestException", errorCode): 1507 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1508 1509 case strings.EqualFold("InternalServerErrorException", errorCode): 1510 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1511 1512 default: 1513 genericError := &smithy.GenericAPIError{ 1514 Code: errorCode, 1515 Message: errorMessage, 1516 } 1517 return genericError 1518 1519 } 1520} 1521 1522type awsRestjson1_deserializeOpDeleteInvitations struct { 1523} 1524 1525func (*awsRestjson1_deserializeOpDeleteInvitations) ID() string { 1526 return "OperationDeserializer" 1527} 1528 1529func (m *awsRestjson1_deserializeOpDeleteInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1530 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1531) { 1532 out, metadata, err = next.HandleDeserialize(ctx, in) 1533 if err != nil { 1534 return out, metadata, err 1535 } 1536 1537 response, ok := out.RawResponse.(*smithyhttp.Response) 1538 if !ok { 1539 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1540 } 1541 1542 if response.StatusCode < 200 || response.StatusCode >= 300 { 1543 return out, metadata, awsRestjson1_deserializeOpErrorDeleteInvitations(response, &metadata) 1544 } 1545 output := &DeleteInvitationsOutput{} 1546 out.Result = output 1547 1548 var buff [1024]byte 1549 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1550 1551 body := io.TeeReader(response.Body, ringBuffer) 1552 1553 decoder := json.NewDecoder(body) 1554 decoder.UseNumber() 1555 var shape interface{} 1556 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1557 var snapshot bytes.Buffer 1558 io.Copy(&snapshot, ringBuffer) 1559 err = &smithy.DeserializationError{ 1560 Err: fmt.Errorf("failed to decode response body, %w", err), 1561 Snapshot: snapshot.Bytes(), 1562 } 1563 return out, metadata, err 1564 } 1565 1566 err = awsRestjson1_deserializeOpDocumentDeleteInvitationsOutput(&output, shape) 1567 if err != nil { 1568 var snapshot bytes.Buffer 1569 io.Copy(&snapshot, ringBuffer) 1570 return out, metadata, &smithy.DeserializationError{ 1571 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1572 Snapshot: snapshot.Bytes(), 1573 } 1574 } 1575 1576 return out, metadata, err 1577} 1578 1579func awsRestjson1_deserializeOpErrorDeleteInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1580 var errorBuffer bytes.Buffer 1581 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1582 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1583 } 1584 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1585 1586 errorCode := "UnknownError" 1587 errorMessage := errorCode 1588 1589 code := response.Header.Get("X-Amzn-ErrorType") 1590 if len(code) != 0 { 1591 errorCode = restjson.SanitizeErrorCode(code) 1592 } 1593 1594 var buff [1024]byte 1595 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1596 1597 body := io.TeeReader(errorBody, ringBuffer) 1598 decoder := json.NewDecoder(body) 1599 decoder.UseNumber() 1600 code, message, err := restjson.GetErrorInfo(decoder) 1601 if err != nil { 1602 var snapshot bytes.Buffer 1603 io.Copy(&snapshot, ringBuffer) 1604 err = &smithy.DeserializationError{ 1605 Err: fmt.Errorf("failed to decode response body, %w", err), 1606 Snapshot: snapshot.Bytes(), 1607 } 1608 return err 1609 } 1610 1611 errorBody.Seek(0, io.SeekStart) 1612 if len(code) != 0 { 1613 errorCode = restjson.SanitizeErrorCode(code) 1614 } 1615 if len(message) != 0 { 1616 errorMessage = message 1617 } 1618 1619 switch { 1620 case strings.EqualFold("BadRequestException", errorCode): 1621 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1622 1623 case strings.EqualFold("InternalServerErrorException", errorCode): 1624 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1625 1626 default: 1627 genericError := &smithy.GenericAPIError{ 1628 Code: errorCode, 1629 Message: errorMessage, 1630 } 1631 return genericError 1632 1633 } 1634} 1635 1636func awsRestjson1_deserializeOpDocumentDeleteInvitationsOutput(v **DeleteInvitationsOutput, value interface{}) error { 1637 if v == nil { 1638 return fmt.Errorf("unexpected nil of type %T", v) 1639 } 1640 if value == nil { 1641 return nil 1642 } 1643 1644 shape, ok := value.(map[string]interface{}) 1645 if !ok { 1646 return fmt.Errorf("unexpected JSON type %v", value) 1647 } 1648 1649 var sv *DeleteInvitationsOutput 1650 if *v == nil { 1651 sv = &DeleteInvitationsOutput{} 1652 } else { 1653 sv = *v 1654 } 1655 1656 for key, value := range shape { 1657 switch key { 1658 case "unprocessedAccounts": 1659 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 1660 return err 1661 } 1662 1663 default: 1664 _, _ = key, value 1665 1666 } 1667 } 1668 *v = sv 1669 return nil 1670} 1671 1672type awsRestjson1_deserializeOpDeleteIPSet struct { 1673} 1674 1675func (*awsRestjson1_deserializeOpDeleteIPSet) ID() string { 1676 return "OperationDeserializer" 1677} 1678 1679func (m *awsRestjson1_deserializeOpDeleteIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1680 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1681) { 1682 out, metadata, err = next.HandleDeserialize(ctx, in) 1683 if err != nil { 1684 return out, metadata, err 1685 } 1686 1687 response, ok := out.RawResponse.(*smithyhttp.Response) 1688 if !ok { 1689 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1690 } 1691 1692 if response.StatusCode < 200 || response.StatusCode >= 300 { 1693 return out, metadata, awsRestjson1_deserializeOpErrorDeleteIPSet(response, &metadata) 1694 } 1695 output := &DeleteIPSetOutput{} 1696 out.Result = output 1697 1698 return out, metadata, err 1699} 1700 1701func awsRestjson1_deserializeOpErrorDeleteIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1702 var errorBuffer bytes.Buffer 1703 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1704 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1705 } 1706 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1707 1708 errorCode := "UnknownError" 1709 errorMessage := errorCode 1710 1711 code := response.Header.Get("X-Amzn-ErrorType") 1712 if len(code) != 0 { 1713 errorCode = restjson.SanitizeErrorCode(code) 1714 } 1715 1716 var buff [1024]byte 1717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1718 1719 body := io.TeeReader(errorBody, ringBuffer) 1720 decoder := json.NewDecoder(body) 1721 decoder.UseNumber() 1722 code, message, err := restjson.GetErrorInfo(decoder) 1723 if err != nil { 1724 var snapshot bytes.Buffer 1725 io.Copy(&snapshot, ringBuffer) 1726 err = &smithy.DeserializationError{ 1727 Err: fmt.Errorf("failed to decode response body, %w", err), 1728 Snapshot: snapshot.Bytes(), 1729 } 1730 return err 1731 } 1732 1733 errorBody.Seek(0, io.SeekStart) 1734 if len(code) != 0 { 1735 errorCode = restjson.SanitizeErrorCode(code) 1736 } 1737 if len(message) != 0 { 1738 errorMessage = message 1739 } 1740 1741 switch { 1742 case strings.EqualFold("BadRequestException", errorCode): 1743 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1744 1745 case strings.EqualFold("InternalServerErrorException", errorCode): 1746 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1747 1748 default: 1749 genericError := &smithy.GenericAPIError{ 1750 Code: errorCode, 1751 Message: errorMessage, 1752 } 1753 return genericError 1754 1755 } 1756} 1757 1758type awsRestjson1_deserializeOpDeleteMembers struct { 1759} 1760 1761func (*awsRestjson1_deserializeOpDeleteMembers) ID() string { 1762 return "OperationDeserializer" 1763} 1764 1765func (m *awsRestjson1_deserializeOpDeleteMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1766 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1767) { 1768 out, metadata, err = next.HandleDeserialize(ctx, in) 1769 if err != nil { 1770 return out, metadata, err 1771 } 1772 1773 response, ok := out.RawResponse.(*smithyhttp.Response) 1774 if !ok { 1775 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1776 } 1777 1778 if response.StatusCode < 200 || response.StatusCode >= 300 { 1779 return out, metadata, awsRestjson1_deserializeOpErrorDeleteMembers(response, &metadata) 1780 } 1781 output := &DeleteMembersOutput{} 1782 out.Result = output 1783 1784 var buff [1024]byte 1785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1786 1787 body := io.TeeReader(response.Body, ringBuffer) 1788 1789 decoder := json.NewDecoder(body) 1790 decoder.UseNumber() 1791 var shape interface{} 1792 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 1800 } 1801 1802 err = awsRestjson1_deserializeOpDocumentDeleteMembersOutput(&output, shape) 1803 if err != nil { 1804 var snapshot bytes.Buffer 1805 io.Copy(&snapshot, ringBuffer) 1806 return out, metadata, &smithy.DeserializationError{ 1807 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1808 Snapshot: snapshot.Bytes(), 1809 } 1810 } 1811 1812 return out, metadata, err 1813} 1814 1815func awsRestjson1_deserializeOpErrorDeleteMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1816 var errorBuffer bytes.Buffer 1817 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1818 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1819 } 1820 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1821 1822 errorCode := "UnknownError" 1823 errorMessage := errorCode 1824 1825 code := response.Header.Get("X-Amzn-ErrorType") 1826 if len(code) != 0 { 1827 errorCode = restjson.SanitizeErrorCode(code) 1828 } 1829 1830 var buff [1024]byte 1831 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1832 1833 body := io.TeeReader(errorBody, ringBuffer) 1834 decoder := json.NewDecoder(body) 1835 decoder.UseNumber() 1836 code, message, err := restjson.GetErrorInfo(decoder) 1837 if err != nil { 1838 var snapshot bytes.Buffer 1839 io.Copy(&snapshot, ringBuffer) 1840 err = &smithy.DeserializationError{ 1841 Err: fmt.Errorf("failed to decode response body, %w", err), 1842 Snapshot: snapshot.Bytes(), 1843 } 1844 return err 1845 } 1846 1847 errorBody.Seek(0, io.SeekStart) 1848 if len(code) != 0 { 1849 errorCode = restjson.SanitizeErrorCode(code) 1850 } 1851 if len(message) != 0 { 1852 errorMessage = message 1853 } 1854 1855 switch { 1856 case strings.EqualFold("BadRequestException", errorCode): 1857 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1858 1859 case strings.EqualFold("InternalServerErrorException", errorCode): 1860 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1861 1862 default: 1863 genericError := &smithy.GenericAPIError{ 1864 Code: errorCode, 1865 Message: errorMessage, 1866 } 1867 return genericError 1868 1869 } 1870} 1871 1872func awsRestjson1_deserializeOpDocumentDeleteMembersOutput(v **DeleteMembersOutput, value interface{}) error { 1873 if v == nil { 1874 return fmt.Errorf("unexpected nil of type %T", v) 1875 } 1876 if value == nil { 1877 return nil 1878 } 1879 1880 shape, ok := value.(map[string]interface{}) 1881 if !ok { 1882 return fmt.Errorf("unexpected JSON type %v", value) 1883 } 1884 1885 var sv *DeleteMembersOutput 1886 if *v == nil { 1887 sv = &DeleteMembersOutput{} 1888 } else { 1889 sv = *v 1890 } 1891 1892 for key, value := range shape { 1893 switch key { 1894 case "unprocessedAccounts": 1895 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 1896 return err 1897 } 1898 1899 default: 1900 _, _ = key, value 1901 1902 } 1903 } 1904 *v = sv 1905 return nil 1906} 1907 1908type awsRestjson1_deserializeOpDeletePublishingDestination struct { 1909} 1910 1911func (*awsRestjson1_deserializeOpDeletePublishingDestination) ID() string { 1912 return "OperationDeserializer" 1913} 1914 1915func (m *awsRestjson1_deserializeOpDeletePublishingDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1916 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1917) { 1918 out, metadata, err = next.HandleDeserialize(ctx, in) 1919 if err != nil { 1920 return out, metadata, err 1921 } 1922 1923 response, ok := out.RawResponse.(*smithyhttp.Response) 1924 if !ok { 1925 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1926 } 1927 1928 if response.StatusCode < 200 || response.StatusCode >= 300 { 1929 return out, metadata, awsRestjson1_deserializeOpErrorDeletePublishingDestination(response, &metadata) 1930 } 1931 output := &DeletePublishingDestinationOutput{} 1932 out.Result = output 1933 1934 return out, metadata, err 1935} 1936 1937func awsRestjson1_deserializeOpErrorDeletePublishingDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1938 var errorBuffer bytes.Buffer 1939 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1940 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1941 } 1942 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1943 1944 errorCode := "UnknownError" 1945 errorMessage := errorCode 1946 1947 code := response.Header.Get("X-Amzn-ErrorType") 1948 if len(code) != 0 { 1949 errorCode = restjson.SanitizeErrorCode(code) 1950 } 1951 1952 var buff [1024]byte 1953 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1954 1955 body := io.TeeReader(errorBody, ringBuffer) 1956 decoder := json.NewDecoder(body) 1957 decoder.UseNumber() 1958 code, message, err := restjson.GetErrorInfo(decoder) 1959 if err != nil { 1960 var snapshot bytes.Buffer 1961 io.Copy(&snapshot, ringBuffer) 1962 err = &smithy.DeserializationError{ 1963 Err: fmt.Errorf("failed to decode response body, %w", err), 1964 Snapshot: snapshot.Bytes(), 1965 } 1966 return err 1967 } 1968 1969 errorBody.Seek(0, io.SeekStart) 1970 if len(code) != 0 { 1971 errorCode = restjson.SanitizeErrorCode(code) 1972 } 1973 if len(message) != 0 { 1974 errorMessage = message 1975 } 1976 1977 switch { 1978 case strings.EqualFold("BadRequestException", errorCode): 1979 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 1980 1981 case strings.EqualFold("InternalServerErrorException", errorCode): 1982 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 1983 1984 default: 1985 genericError := &smithy.GenericAPIError{ 1986 Code: errorCode, 1987 Message: errorMessage, 1988 } 1989 return genericError 1990 1991 } 1992} 1993 1994type awsRestjson1_deserializeOpDeleteThreatIntelSet struct { 1995} 1996 1997func (*awsRestjson1_deserializeOpDeleteThreatIntelSet) ID() string { 1998 return "OperationDeserializer" 1999} 2000 2001func (m *awsRestjson1_deserializeOpDeleteThreatIntelSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2002 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2003) { 2004 out, metadata, err = next.HandleDeserialize(ctx, in) 2005 if err != nil { 2006 return out, metadata, err 2007 } 2008 2009 response, ok := out.RawResponse.(*smithyhttp.Response) 2010 if !ok { 2011 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2012 } 2013 2014 if response.StatusCode < 200 || response.StatusCode >= 300 { 2015 return out, metadata, awsRestjson1_deserializeOpErrorDeleteThreatIntelSet(response, &metadata) 2016 } 2017 output := &DeleteThreatIntelSetOutput{} 2018 out.Result = output 2019 2020 return out, metadata, err 2021} 2022 2023func awsRestjson1_deserializeOpErrorDeleteThreatIntelSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2024 var errorBuffer bytes.Buffer 2025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2027 } 2028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2029 2030 errorCode := "UnknownError" 2031 errorMessage := errorCode 2032 2033 code := response.Header.Get("X-Amzn-ErrorType") 2034 if len(code) != 0 { 2035 errorCode = restjson.SanitizeErrorCode(code) 2036 } 2037 2038 var buff [1024]byte 2039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2040 2041 body := io.TeeReader(errorBody, ringBuffer) 2042 decoder := json.NewDecoder(body) 2043 decoder.UseNumber() 2044 code, message, err := restjson.GetErrorInfo(decoder) 2045 if err != nil { 2046 var snapshot bytes.Buffer 2047 io.Copy(&snapshot, ringBuffer) 2048 err = &smithy.DeserializationError{ 2049 Err: fmt.Errorf("failed to decode response body, %w", err), 2050 Snapshot: snapshot.Bytes(), 2051 } 2052 return err 2053 } 2054 2055 errorBody.Seek(0, io.SeekStart) 2056 if len(code) != 0 { 2057 errorCode = restjson.SanitizeErrorCode(code) 2058 } 2059 if len(message) != 0 { 2060 errorMessage = message 2061 } 2062 2063 switch { 2064 case strings.EqualFold("BadRequestException", errorCode): 2065 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2066 2067 case strings.EqualFold("InternalServerErrorException", errorCode): 2068 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2069 2070 default: 2071 genericError := &smithy.GenericAPIError{ 2072 Code: errorCode, 2073 Message: errorMessage, 2074 } 2075 return genericError 2076 2077 } 2078} 2079 2080type awsRestjson1_deserializeOpDescribeOrganizationConfiguration struct { 2081} 2082 2083func (*awsRestjson1_deserializeOpDescribeOrganizationConfiguration) ID() string { 2084 return "OperationDeserializer" 2085} 2086 2087func (m *awsRestjson1_deserializeOpDescribeOrganizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2088 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2089) { 2090 out, metadata, err = next.HandleDeserialize(ctx, in) 2091 if err != nil { 2092 return out, metadata, err 2093 } 2094 2095 response, ok := out.RawResponse.(*smithyhttp.Response) 2096 if !ok { 2097 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2098 } 2099 2100 if response.StatusCode < 200 || response.StatusCode >= 300 { 2101 return out, metadata, awsRestjson1_deserializeOpErrorDescribeOrganizationConfiguration(response, &metadata) 2102 } 2103 output := &DescribeOrganizationConfigurationOutput{} 2104 out.Result = output 2105 2106 var buff [1024]byte 2107 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2108 2109 body := io.TeeReader(response.Body, ringBuffer) 2110 2111 decoder := json.NewDecoder(body) 2112 decoder.UseNumber() 2113 var shape interface{} 2114 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2115 var snapshot bytes.Buffer 2116 io.Copy(&snapshot, ringBuffer) 2117 err = &smithy.DeserializationError{ 2118 Err: fmt.Errorf("failed to decode response body, %w", err), 2119 Snapshot: snapshot.Bytes(), 2120 } 2121 return out, metadata, err 2122 } 2123 2124 err = awsRestjson1_deserializeOpDocumentDescribeOrganizationConfigurationOutput(&output, shape) 2125 if err != nil { 2126 var snapshot bytes.Buffer 2127 io.Copy(&snapshot, ringBuffer) 2128 return out, metadata, &smithy.DeserializationError{ 2129 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2130 Snapshot: snapshot.Bytes(), 2131 } 2132 } 2133 2134 return out, metadata, err 2135} 2136 2137func awsRestjson1_deserializeOpErrorDescribeOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2138 var errorBuffer bytes.Buffer 2139 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2140 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2141 } 2142 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2143 2144 errorCode := "UnknownError" 2145 errorMessage := errorCode 2146 2147 code := response.Header.Get("X-Amzn-ErrorType") 2148 if len(code) != 0 { 2149 errorCode = restjson.SanitizeErrorCode(code) 2150 } 2151 2152 var buff [1024]byte 2153 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2154 2155 body := io.TeeReader(errorBody, ringBuffer) 2156 decoder := json.NewDecoder(body) 2157 decoder.UseNumber() 2158 code, message, err := restjson.GetErrorInfo(decoder) 2159 if err != nil { 2160 var snapshot bytes.Buffer 2161 io.Copy(&snapshot, ringBuffer) 2162 err = &smithy.DeserializationError{ 2163 Err: fmt.Errorf("failed to decode response body, %w", err), 2164 Snapshot: snapshot.Bytes(), 2165 } 2166 return err 2167 } 2168 2169 errorBody.Seek(0, io.SeekStart) 2170 if len(code) != 0 { 2171 errorCode = restjson.SanitizeErrorCode(code) 2172 } 2173 if len(message) != 0 { 2174 errorMessage = message 2175 } 2176 2177 switch { 2178 case strings.EqualFold("BadRequestException", errorCode): 2179 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2180 2181 case strings.EqualFold("InternalServerErrorException", errorCode): 2182 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2183 2184 default: 2185 genericError := &smithy.GenericAPIError{ 2186 Code: errorCode, 2187 Message: errorMessage, 2188 } 2189 return genericError 2190 2191 } 2192} 2193 2194func awsRestjson1_deserializeOpDocumentDescribeOrganizationConfigurationOutput(v **DescribeOrganizationConfigurationOutput, value interface{}) error { 2195 if v == nil { 2196 return fmt.Errorf("unexpected nil of type %T", v) 2197 } 2198 if value == nil { 2199 return nil 2200 } 2201 2202 shape, ok := value.(map[string]interface{}) 2203 if !ok { 2204 return fmt.Errorf("unexpected JSON type %v", value) 2205 } 2206 2207 var sv *DescribeOrganizationConfigurationOutput 2208 if *v == nil { 2209 sv = &DescribeOrganizationConfigurationOutput{} 2210 } else { 2211 sv = *v 2212 } 2213 2214 for key, value := range shape { 2215 switch key { 2216 case "autoEnable": 2217 if value != nil { 2218 jtv, ok := value.(bool) 2219 if !ok { 2220 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 2221 } 2222 sv.AutoEnable = jtv 2223 } 2224 2225 case "dataSources": 2226 if err := awsRestjson1_deserializeDocumentOrganizationDataSourceConfigurationsResult(&sv.DataSources, value); err != nil { 2227 return err 2228 } 2229 2230 case "memberAccountLimitReached": 2231 if value != nil { 2232 jtv, ok := value.(bool) 2233 if !ok { 2234 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 2235 } 2236 sv.MemberAccountLimitReached = jtv 2237 } 2238 2239 default: 2240 _, _ = key, value 2241 2242 } 2243 } 2244 *v = sv 2245 return nil 2246} 2247 2248type awsRestjson1_deserializeOpDescribePublishingDestination struct { 2249} 2250 2251func (*awsRestjson1_deserializeOpDescribePublishingDestination) ID() string { 2252 return "OperationDeserializer" 2253} 2254 2255func (m *awsRestjson1_deserializeOpDescribePublishingDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2256 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2257) { 2258 out, metadata, err = next.HandleDeserialize(ctx, in) 2259 if err != nil { 2260 return out, metadata, err 2261 } 2262 2263 response, ok := out.RawResponse.(*smithyhttp.Response) 2264 if !ok { 2265 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2266 } 2267 2268 if response.StatusCode < 200 || response.StatusCode >= 300 { 2269 return out, metadata, awsRestjson1_deserializeOpErrorDescribePublishingDestination(response, &metadata) 2270 } 2271 output := &DescribePublishingDestinationOutput{} 2272 out.Result = output 2273 2274 var buff [1024]byte 2275 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2276 2277 body := io.TeeReader(response.Body, ringBuffer) 2278 2279 decoder := json.NewDecoder(body) 2280 decoder.UseNumber() 2281 var shape interface{} 2282 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2283 var snapshot bytes.Buffer 2284 io.Copy(&snapshot, ringBuffer) 2285 err = &smithy.DeserializationError{ 2286 Err: fmt.Errorf("failed to decode response body, %w", err), 2287 Snapshot: snapshot.Bytes(), 2288 } 2289 return out, metadata, err 2290 } 2291 2292 err = awsRestjson1_deserializeOpDocumentDescribePublishingDestinationOutput(&output, shape) 2293 if err != nil { 2294 var snapshot bytes.Buffer 2295 io.Copy(&snapshot, ringBuffer) 2296 return out, metadata, &smithy.DeserializationError{ 2297 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2298 Snapshot: snapshot.Bytes(), 2299 } 2300 } 2301 2302 return out, metadata, err 2303} 2304 2305func awsRestjson1_deserializeOpErrorDescribePublishingDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2306 var errorBuffer bytes.Buffer 2307 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2308 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2309 } 2310 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2311 2312 errorCode := "UnknownError" 2313 errorMessage := errorCode 2314 2315 code := response.Header.Get("X-Amzn-ErrorType") 2316 if len(code) != 0 { 2317 errorCode = restjson.SanitizeErrorCode(code) 2318 } 2319 2320 var buff [1024]byte 2321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2322 2323 body := io.TeeReader(errorBody, ringBuffer) 2324 decoder := json.NewDecoder(body) 2325 decoder.UseNumber() 2326 code, message, err := restjson.GetErrorInfo(decoder) 2327 if err != nil { 2328 var snapshot bytes.Buffer 2329 io.Copy(&snapshot, ringBuffer) 2330 err = &smithy.DeserializationError{ 2331 Err: fmt.Errorf("failed to decode response body, %w", err), 2332 Snapshot: snapshot.Bytes(), 2333 } 2334 return err 2335 } 2336 2337 errorBody.Seek(0, io.SeekStart) 2338 if len(code) != 0 { 2339 errorCode = restjson.SanitizeErrorCode(code) 2340 } 2341 if len(message) != 0 { 2342 errorMessage = message 2343 } 2344 2345 switch { 2346 case strings.EqualFold("BadRequestException", errorCode): 2347 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2348 2349 case strings.EqualFold("InternalServerErrorException", errorCode): 2350 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2351 2352 default: 2353 genericError := &smithy.GenericAPIError{ 2354 Code: errorCode, 2355 Message: errorMessage, 2356 } 2357 return genericError 2358 2359 } 2360} 2361 2362func awsRestjson1_deserializeOpDocumentDescribePublishingDestinationOutput(v **DescribePublishingDestinationOutput, value interface{}) error { 2363 if v == nil { 2364 return fmt.Errorf("unexpected nil of type %T", v) 2365 } 2366 if value == nil { 2367 return nil 2368 } 2369 2370 shape, ok := value.(map[string]interface{}) 2371 if !ok { 2372 return fmt.Errorf("unexpected JSON type %v", value) 2373 } 2374 2375 var sv *DescribePublishingDestinationOutput 2376 if *v == nil { 2377 sv = &DescribePublishingDestinationOutput{} 2378 } else { 2379 sv = *v 2380 } 2381 2382 for key, value := range shape { 2383 switch key { 2384 case "destinationId": 2385 if value != nil { 2386 jtv, ok := value.(string) 2387 if !ok { 2388 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2389 } 2390 sv.DestinationId = ptr.String(jtv) 2391 } 2392 2393 case "destinationProperties": 2394 if err := awsRestjson1_deserializeDocumentDestinationProperties(&sv.DestinationProperties, value); err != nil { 2395 return err 2396 } 2397 2398 case "destinationType": 2399 if value != nil { 2400 jtv, ok := value.(string) 2401 if !ok { 2402 return fmt.Errorf("expected DestinationType to be of type string, got %T instead", value) 2403 } 2404 sv.DestinationType = types.DestinationType(jtv) 2405 } 2406 2407 case "publishingFailureStartTimestamp": 2408 if value != nil { 2409 jtv, ok := value.(json.Number) 2410 if !ok { 2411 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 2412 } 2413 i64, err := jtv.Int64() 2414 if err != nil { 2415 return err 2416 } 2417 sv.PublishingFailureStartTimestamp = i64 2418 } 2419 2420 case "status": 2421 if value != nil { 2422 jtv, ok := value.(string) 2423 if !ok { 2424 return fmt.Errorf("expected PublishingStatus to be of type string, got %T instead", value) 2425 } 2426 sv.Status = types.PublishingStatus(jtv) 2427 } 2428 2429 default: 2430 _, _ = key, value 2431 2432 } 2433 } 2434 *v = sv 2435 return nil 2436} 2437 2438type awsRestjson1_deserializeOpDisableOrganizationAdminAccount struct { 2439} 2440 2441func (*awsRestjson1_deserializeOpDisableOrganizationAdminAccount) ID() string { 2442 return "OperationDeserializer" 2443} 2444 2445func (m *awsRestjson1_deserializeOpDisableOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2446 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2447) { 2448 out, metadata, err = next.HandleDeserialize(ctx, in) 2449 if err != nil { 2450 return out, metadata, err 2451 } 2452 2453 response, ok := out.RawResponse.(*smithyhttp.Response) 2454 if !ok { 2455 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2456 } 2457 2458 if response.StatusCode < 200 || response.StatusCode >= 300 { 2459 return out, metadata, awsRestjson1_deserializeOpErrorDisableOrganizationAdminAccount(response, &metadata) 2460 } 2461 output := &DisableOrganizationAdminAccountOutput{} 2462 out.Result = output 2463 2464 return out, metadata, err 2465} 2466 2467func awsRestjson1_deserializeOpErrorDisableOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2468 var errorBuffer bytes.Buffer 2469 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2470 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2471 } 2472 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2473 2474 errorCode := "UnknownError" 2475 errorMessage := errorCode 2476 2477 code := response.Header.Get("X-Amzn-ErrorType") 2478 if len(code) != 0 { 2479 errorCode = restjson.SanitizeErrorCode(code) 2480 } 2481 2482 var buff [1024]byte 2483 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2484 2485 body := io.TeeReader(errorBody, ringBuffer) 2486 decoder := json.NewDecoder(body) 2487 decoder.UseNumber() 2488 code, message, err := restjson.GetErrorInfo(decoder) 2489 if err != nil { 2490 var snapshot bytes.Buffer 2491 io.Copy(&snapshot, ringBuffer) 2492 err = &smithy.DeserializationError{ 2493 Err: fmt.Errorf("failed to decode response body, %w", err), 2494 Snapshot: snapshot.Bytes(), 2495 } 2496 return err 2497 } 2498 2499 errorBody.Seek(0, io.SeekStart) 2500 if len(code) != 0 { 2501 errorCode = restjson.SanitizeErrorCode(code) 2502 } 2503 if len(message) != 0 { 2504 errorMessage = message 2505 } 2506 2507 switch { 2508 case strings.EqualFold("BadRequestException", errorCode): 2509 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2510 2511 case strings.EqualFold("InternalServerErrorException", errorCode): 2512 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2513 2514 default: 2515 genericError := &smithy.GenericAPIError{ 2516 Code: errorCode, 2517 Message: errorMessage, 2518 } 2519 return genericError 2520 2521 } 2522} 2523 2524type awsRestjson1_deserializeOpDisassociateFromMasterAccount struct { 2525} 2526 2527func (*awsRestjson1_deserializeOpDisassociateFromMasterAccount) ID() string { 2528 return "OperationDeserializer" 2529} 2530 2531func (m *awsRestjson1_deserializeOpDisassociateFromMasterAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2532 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2533) { 2534 out, metadata, err = next.HandleDeserialize(ctx, in) 2535 if err != nil { 2536 return out, metadata, err 2537 } 2538 2539 response, ok := out.RawResponse.(*smithyhttp.Response) 2540 if !ok { 2541 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2542 } 2543 2544 if response.StatusCode < 200 || response.StatusCode >= 300 { 2545 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateFromMasterAccount(response, &metadata) 2546 } 2547 output := &DisassociateFromMasterAccountOutput{} 2548 out.Result = output 2549 2550 return out, metadata, err 2551} 2552 2553func awsRestjson1_deserializeOpErrorDisassociateFromMasterAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2554 var errorBuffer bytes.Buffer 2555 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2556 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2557 } 2558 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2559 2560 errorCode := "UnknownError" 2561 errorMessage := errorCode 2562 2563 code := response.Header.Get("X-Amzn-ErrorType") 2564 if len(code) != 0 { 2565 errorCode = restjson.SanitizeErrorCode(code) 2566 } 2567 2568 var buff [1024]byte 2569 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2570 2571 body := io.TeeReader(errorBody, ringBuffer) 2572 decoder := json.NewDecoder(body) 2573 decoder.UseNumber() 2574 code, message, err := restjson.GetErrorInfo(decoder) 2575 if err != nil { 2576 var snapshot bytes.Buffer 2577 io.Copy(&snapshot, ringBuffer) 2578 err = &smithy.DeserializationError{ 2579 Err: fmt.Errorf("failed to decode response body, %w", err), 2580 Snapshot: snapshot.Bytes(), 2581 } 2582 return err 2583 } 2584 2585 errorBody.Seek(0, io.SeekStart) 2586 if len(code) != 0 { 2587 errorCode = restjson.SanitizeErrorCode(code) 2588 } 2589 if len(message) != 0 { 2590 errorMessage = message 2591 } 2592 2593 switch { 2594 case strings.EqualFold("BadRequestException", errorCode): 2595 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2596 2597 case strings.EqualFold("InternalServerErrorException", errorCode): 2598 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2599 2600 default: 2601 genericError := &smithy.GenericAPIError{ 2602 Code: errorCode, 2603 Message: errorMessage, 2604 } 2605 return genericError 2606 2607 } 2608} 2609 2610type awsRestjson1_deserializeOpDisassociateMembers struct { 2611} 2612 2613func (*awsRestjson1_deserializeOpDisassociateMembers) ID() string { 2614 return "OperationDeserializer" 2615} 2616 2617func (m *awsRestjson1_deserializeOpDisassociateMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2619) { 2620 out, metadata, err = next.HandleDeserialize(ctx, in) 2621 if err != nil { 2622 return out, metadata, err 2623 } 2624 2625 response, ok := out.RawResponse.(*smithyhttp.Response) 2626 if !ok { 2627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2628 } 2629 2630 if response.StatusCode < 200 || response.StatusCode >= 300 { 2631 return out, metadata, awsRestjson1_deserializeOpErrorDisassociateMembers(response, &metadata) 2632 } 2633 output := &DisassociateMembersOutput{} 2634 out.Result = output 2635 2636 var buff [1024]byte 2637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2638 2639 body := io.TeeReader(response.Body, ringBuffer) 2640 2641 decoder := json.NewDecoder(body) 2642 decoder.UseNumber() 2643 var shape interface{} 2644 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2645 var snapshot bytes.Buffer 2646 io.Copy(&snapshot, ringBuffer) 2647 err = &smithy.DeserializationError{ 2648 Err: fmt.Errorf("failed to decode response body, %w", err), 2649 Snapshot: snapshot.Bytes(), 2650 } 2651 return out, metadata, err 2652 } 2653 2654 err = awsRestjson1_deserializeOpDocumentDisassociateMembersOutput(&output, shape) 2655 if err != nil { 2656 var snapshot bytes.Buffer 2657 io.Copy(&snapshot, ringBuffer) 2658 return out, metadata, &smithy.DeserializationError{ 2659 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2660 Snapshot: snapshot.Bytes(), 2661 } 2662 } 2663 2664 return out, metadata, err 2665} 2666 2667func awsRestjson1_deserializeOpErrorDisassociateMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2668 var errorBuffer bytes.Buffer 2669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2671 } 2672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2673 2674 errorCode := "UnknownError" 2675 errorMessage := errorCode 2676 2677 code := response.Header.Get("X-Amzn-ErrorType") 2678 if len(code) != 0 { 2679 errorCode = restjson.SanitizeErrorCode(code) 2680 } 2681 2682 var buff [1024]byte 2683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2684 2685 body := io.TeeReader(errorBody, ringBuffer) 2686 decoder := json.NewDecoder(body) 2687 decoder.UseNumber() 2688 code, message, err := restjson.GetErrorInfo(decoder) 2689 if err != nil { 2690 var snapshot bytes.Buffer 2691 io.Copy(&snapshot, ringBuffer) 2692 err = &smithy.DeserializationError{ 2693 Err: fmt.Errorf("failed to decode response body, %w", err), 2694 Snapshot: snapshot.Bytes(), 2695 } 2696 return err 2697 } 2698 2699 errorBody.Seek(0, io.SeekStart) 2700 if len(code) != 0 { 2701 errorCode = restjson.SanitizeErrorCode(code) 2702 } 2703 if len(message) != 0 { 2704 errorMessage = message 2705 } 2706 2707 switch { 2708 case strings.EqualFold("BadRequestException", errorCode): 2709 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2710 2711 case strings.EqualFold("InternalServerErrorException", errorCode): 2712 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2713 2714 default: 2715 genericError := &smithy.GenericAPIError{ 2716 Code: errorCode, 2717 Message: errorMessage, 2718 } 2719 return genericError 2720 2721 } 2722} 2723 2724func awsRestjson1_deserializeOpDocumentDisassociateMembersOutput(v **DisassociateMembersOutput, value interface{}) error { 2725 if v == nil { 2726 return fmt.Errorf("unexpected nil of type %T", v) 2727 } 2728 if value == nil { 2729 return nil 2730 } 2731 2732 shape, ok := value.(map[string]interface{}) 2733 if !ok { 2734 return fmt.Errorf("unexpected JSON type %v", value) 2735 } 2736 2737 var sv *DisassociateMembersOutput 2738 if *v == nil { 2739 sv = &DisassociateMembersOutput{} 2740 } else { 2741 sv = *v 2742 } 2743 2744 for key, value := range shape { 2745 switch key { 2746 case "unprocessedAccounts": 2747 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 2748 return err 2749 } 2750 2751 default: 2752 _, _ = key, value 2753 2754 } 2755 } 2756 *v = sv 2757 return nil 2758} 2759 2760type awsRestjson1_deserializeOpEnableOrganizationAdminAccount struct { 2761} 2762 2763func (*awsRestjson1_deserializeOpEnableOrganizationAdminAccount) ID() string { 2764 return "OperationDeserializer" 2765} 2766 2767func (m *awsRestjson1_deserializeOpEnableOrganizationAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2768 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2769) { 2770 out, metadata, err = next.HandleDeserialize(ctx, in) 2771 if err != nil { 2772 return out, metadata, err 2773 } 2774 2775 response, ok := out.RawResponse.(*smithyhttp.Response) 2776 if !ok { 2777 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2778 } 2779 2780 if response.StatusCode < 200 || response.StatusCode >= 300 { 2781 return out, metadata, awsRestjson1_deserializeOpErrorEnableOrganizationAdminAccount(response, &metadata) 2782 } 2783 output := &EnableOrganizationAdminAccountOutput{} 2784 out.Result = output 2785 2786 return out, metadata, err 2787} 2788 2789func awsRestjson1_deserializeOpErrorEnableOrganizationAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2790 var errorBuffer bytes.Buffer 2791 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2792 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2793 } 2794 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2795 2796 errorCode := "UnknownError" 2797 errorMessage := errorCode 2798 2799 code := response.Header.Get("X-Amzn-ErrorType") 2800 if len(code) != 0 { 2801 errorCode = restjson.SanitizeErrorCode(code) 2802 } 2803 2804 var buff [1024]byte 2805 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2806 2807 body := io.TeeReader(errorBody, ringBuffer) 2808 decoder := json.NewDecoder(body) 2809 decoder.UseNumber() 2810 code, message, err := restjson.GetErrorInfo(decoder) 2811 if err != nil { 2812 var snapshot bytes.Buffer 2813 io.Copy(&snapshot, ringBuffer) 2814 err = &smithy.DeserializationError{ 2815 Err: fmt.Errorf("failed to decode response body, %w", err), 2816 Snapshot: snapshot.Bytes(), 2817 } 2818 return err 2819 } 2820 2821 errorBody.Seek(0, io.SeekStart) 2822 if len(code) != 0 { 2823 errorCode = restjson.SanitizeErrorCode(code) 2824 } 2825 if len(message) != 0 { 2826 errorMessage = message 2827 } 2828 2829 switch { 2830 case strings.EqualFold("BadRequestException", errorCode): 2831 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2832 2833 case strings.EqualFold("InternalServerErrorException", errorCode): 2834 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2835 2836 default: 2837 genericError := &smithy.GenericAPIError{ 2838 Code: errorCode, 2839 Message: errorMessage, 2840 } 2841 return genericError 2842 2843 } 2844} 2845 2846type awsRestjson1_deserializeOpGetDetector struct { 2847} 2848 2849func (*awsRestjson1_deserializeOpGetDetector) ID() string { 2850 return "OperationDeserializer" 2851} 2852 2853func (m *awsRestjson1_deserializeOpGetDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2854 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2855) { 2856 out, metadata, err = next.HandleDeserialize(ctx, in) 2857 if err != nil { 2858 return out, metadata, err 2859 } 2860 2861 response, ok := out.RawResponse.(*smithyhttp.Response) 2862 if !ok { 2863 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2864 } 2865 2866 if response.StatusCode < 200 || response.StatusCode >= 300 { 2867 return out, metadata, awsRestjson1_deserializeOpErrorGetDetector(response, &metadata) 2868 } 2869 output := &GetDetectorOutput{} 2870 out.Result = output 2871 2872 var buff [1024]byte 2873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2874 2875 body := io.TeeReader(response.Body, ringBuffer) 2876 2877 decoder := json.NewDecoder(body) 2878 decoder.UseNumber() 2879 var shape interface{} 2880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2881 var snapshot bytes.Buffer 2882 io.Copy(&snapshot, ringBuffer) 2883 err = &smithy.DeserializationError{ 2884 Err: fmt.Errorf("failed to decode response body, %w", err), 2885 Snapshot: snapshot.Bytes(), 2886 } 2887 return out, metadata, err 2888 } 2889 2890 err = awsRestjson1_deserializeOpDocumentGetDetectorOutput(&output, shape) 2891 if err != nil { 2892 var snapshot bytes.Buffer 2893 io.Copy(&snapshot, ringBuffer) 2894 return out, metadata, &smithy.DeserializationError{ 2895 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2896 Snapshot: snapshot.Bytes(), 2897 } 2898 } 2899 2900 return out, metadata, err 2901} 2902 2903func awsRestjson1_deserializeOpErrorGetDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2904 var errorBuffer bytes.Buffer 2905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2907 } 2908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2909 2910 errorCode := "UnknownError" 2911 errorMessage := errorCode 2912 2913 code := response.Header.Get("X-Amzn-ErrorType") 2914 if len(code) != 0 { 2915 errorCode = restjson.SanitizeErrorCode(code) 2916 } 2917 2918 var buff [1024]byte 2919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2920 2921 body := io.TeeReader(errorBody, ringBuffer) 2922 decoder := json.NewDecoder(body) 2923 decoder.UseNumber() 2924 code, message, err := restjson.GetErrorInfo(decoder) 2925 if err != nil { 2926 var snapshot bytes.Buffer 2927 io.Copy(&snapshot, ringBuffer) 2928 err = &smithy.DeserializationError{ 2929 Err: fmt.Errorf("failed to decode response body, %w", err), 2930 Snapshot: snapshot.Bytes(), 2931 } 2932 return err 2933 } 2934 2935 errorBody.Seek(0, io.SeekStart) 2936 if len(code) != 0 { 2937 errorCode = restjson.SanitizeErrorCode(code) 2938 } 2939 if len(message) != 0 { 2940 errorMessage = message 2941 } 2942 2943 switch { 2944 case strings.EqualFold("BadRequestException", errorCode): 2945 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 2946 2947 case strings.EqualFold("InternalServerErrorException", errorCode): 2948 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 2949 2950 default: 2951 genericError := &smithy.GenericAPIError{ 2952 Code: errorCode, 2953 Message: errorMessage, 2954 } 2955 return genericError 2956 2957 } 2958} 2959 2960func awsRestjson1_deserializeOpDocumentGetDetectorOutput(v **GetDetectorOutput, value interface{}) error { 2961 if v == nil { 2962 return fmt.Errorf("unexpected nil of type %T", v) 2963 } 2964 if value == nil { 2965 return nil 2966 } 2967 2968 shape, ok := value.(map[string]interface{}) 2969 if !ok { 2970 return fmt.Errorf("unexpected JSON type %v", value) 2971 } 2972 2973 var sv *GetDetectorOutput 2974 if *v == nil { 2975 sv = &GetDetectorOutput{} 2976 } else { 2977 sv = *v 2978 } 2979 2980 for key, value := range shape { 2981 switch key { 2982 case "createdAt": 2983 if value != nil { 2984 jtv, ok := value.(string) 2985 if !ok { 2986 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2987 } 2988 sv.CreatedAt = ptr.String(jtv) 2989 } 2990 2991 case "dataSources": 2992 if err := awsRestjson1_deserializeDocumentDataSourceConfigurationsResult(&sv.DataSources, value); err != nil { 2993 return err 2994 } 2995 2996 case "findingPublishingFrequency": 2997 if value != nil { 2998 jtv, ok := value.(string) 2999 if !ok { 3000 return fmt.Errorf("expected FindingPublishingFrequency to be of type string, got %T instead", value) 3001 } 3002 sv.FindingPublishingFrequency = types.FindingPublishingFrequency(jtv) 3003 } 3004 3005 case "serviceRole": 3006 if value != nil { 3007 jtv, ok := value.(string) 3008 if !ok { 3009 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3010 } 3011 sv.ServiceRole = ptr.String(jtv) 3012 } 3013 3014 case "status": 3015 if value != nil { 3016 jtv, ok := value.(string) 3017 if !ok { 3018 return fmt.Errorf("expected DetectorStatus to be of type string, got %T instead", value) 3019 } 3020 sv.Status = types.DetectorStatus(jtv) 3021 } 3022 3023 case "tags": 3024 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3025 return err 3026 } 3027 3028 case "updatedAt": 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.UpdatedAt = ptr.String(jtv) 3035 } 3036 3037 default: 3038 _, _ = key, value 3039 3040 } 3041 } 3042 *v = sv 3043 return nil 3044} 3045 3046type awsRestjson1_deserializeOpGetFilter struct { 3047} 3048 3049func (*awsRestjson1_deserializeOpGetFilter) ID() string { 3050 return "OperationDeserializer" 3051} 3052 3053func (m *awsRestjson1_deserializeOpGetFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3054 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3055) { 3056 out, metadata, err = next.HandleDeserialize(ctx, in) 3057 if err != nil { 3058 return out, metadata, err 3059 } 3060 3061 response, ok := out.RawResponse.(*smithyhttp.Response) 3062 if !ok { 3063 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3064 } 3065 3066 if response.StatusCode < 200 || response.StatusCode >= 300 { 3067 return out, metadata, awsRestjson1_deserializeOpErrorGetFilter(response, &metadata) 3068 } 3069 output := &GetFilterOutput{} 3070 out.Result = output 3071 3072 var buff [1024]byte 3073 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3074 3075 body := io.TeeReader(response.Body, ringBuffer) 3076 3077 decoder := json.NewDecoder(body) 3078 decoder.UseNumber() 3079 var shape interface{} 3080 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3081 var snapshot bytes.Buffer 3082 io.Copy(&snapshot, ringBuffer) 3083 err = &smithy.DeserializationError{ 3084 Err: fmt.Errorf("failed to decode response body, %w", err), 3085 Snapshot: snapshot.Bytes(), 3086 } 3087 return out, metadata, err 3088 } 3089 3090 err = awsRestjson1_deserializeOpDocumentGetFilterOutput(&output, shape) 3091 if err != nil { 3092 var snapshot bytes.Buffer 3093 io.Copy(&snapshot, ringBuffer) 3094 return out, metadata, &smithy.DeserializationError{ 3095 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3096 Snapshot: snapshot.Bytes(), 3097 } 3098 } 3099 3100 return out, metadata, err 3101} 3102 3103func awsRestjson1_deserializeOpErrorGetFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3104 var errorBuffer bytes.Buffer 3105 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3106 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3107 } 3108 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3109 3110 errorCode := "UnknownError" 3111 errorMessage := errorCode 3112 3113 code := response.Header.Get("X-Amzn-ErrorType") 3114 if len(code) != 0 { 3115 errorCode = restjson.SanitizeErrorCode(code) 3116 } 3117 3118 var buff [1024]byte 3119 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3120 3121 body := io.TeeReader(errorBody, ringBuffer) 3122 decoder := json.NewDecoder(body) 3123 decoder.UseNumber() 3124 code, message, err := restjson.GetErrorInfo(decoder) 3125 if err != nil { 3126 var snapshot bytes.Buffer 3127 io.Copy(&snapshot, ringBuffer) 3128 err = &smithy.DeserializationError{ 3129 Err: fmt.Errorf("failed to decode response body, %w", err), 3130 Snapshot: snapshot.Bytes(), 3131 } 3132 return err 3133 } 3134 3135 errorBody.Seek(0, io.SeekStart) 3136 if len(code) != 0 { 3137 errorCode = restjson.SanitizeErrorCode(code) 3138 } 3139 if len(message) != 0 { 3140 errorMessage = message 3141 } 3142 3143 switch { 3144 case strings.EqualFold("BadRequestException", errorCode): 3145 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3146 3147 case strings.EqualFold("InternalServerErrorException", errorCode): 3148 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3149 3150 default: 3151 genericError := &smithy.GenericAPIError{ 3152 Code: errorCode, 3153 Message: errorMessage, 3154 } 3155 return genericError 3156 3157 } 3158} 3159 3160func awsRestjson1_deserializeOpDocumentGetFilterOutput(v **GetFilterOutput, value interface{}) error { 3161 if v == nil { 3162 return fmt.Errorf("unexpected nil of type %T", v) 3163 } 3164 if value == nil { 3165 return nil 3166 } 3167 3168 shape, ok := value.(map[string]interface{}) 3169 if !ok { 3170 return fmt.Errorf("unexpected JSON type %v", value) 3171 } 3172 3173 var sv *GetFilterOutput 3174 if *v == nil { 3175 sv = &GetFilterOutput{} 3176 } else { 3177 sv = *v 3178 } 3179 3180 for key, value := range shape { 3181 switch key { 3182 case "action": 3183 if value != nil { 3184 jtv, ok := value.(string) 3185 if !ok { 3186 return fmt.Errorf("expected FilterAction to be of type string, got %T instead", value) 3187 } 3188 sv.Action = types.FilterAction(jtv) 3189 } 3190 3191 case "description": 3192 if value != nil { 3193 jtv, ok := value.(string) 3194 if !ok { 3195 return fmt.Errorf("expected FilterDescription to be of type string, got %T instead", value) 3196 } 3197 sv.Description = ptr.String(jtv) 3198 } 3199 3200 case "findingCriteria": 3201 if err := awsRestjson1_deserializeDocumentFindingCriteria(&sv.FindingCriteria, value); err != nil { 3202 return err 3203 } 3204 3205 case "name": 3206 if value != nil { 3207 jtv, ok := value.(string) 3208 if !ok { 3209 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 3210 } 3211 sv.Name = ptr.String(jtv) 3212 } 3213 3214 case "rank": 3215 if value != nil { 3216 jtv, ok := value.(json.Number) 3217 if !ok { 3218 return fmt.Errorf("expected FilterRank to be json.Number, got %T instead", value) 3219 } 3220 i64, err := jtv.Int64() 3221 if err != nil { 3222 return err 3223 } 3224 sv.Rank = int32(i64) 3225 } 3226 3227 case "tags": 3228 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3229 return err 3230 } 3231 3232 default: 3233 _, _ = key, value 3234 3235 } 3236 } 3237 *v = sv 3238 return nil 3239} 3240 3241type awsRestjson1_deserializeOpGetFindings struct { 3242} 3243 3244func (*awsRestjson1_deserializeOpGetFindings) ID() string { 3245 return "OperationDeserializer" 3246} 3247 3248func (m *awsRestjson1_deserializeOpGetFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3249 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3250) { 3251 out, metadata, err = next.HandleDeserialize(ctx, in) 3252 if err != nil { 3253 return out, metadata, err 3254 } 3255 3256 response, ok := out.RawResponse.(*smithyhttp.Response) 3257 if !ok { 3258 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3259 } 3260 3261 if response.StatusCode < 200 || response.StatusCode >= 300 { 3262 return out, metadata, awsRestjson1_deserializeOpErrorGetFindings(response, &metadata) 3263 } 3264 output := &GetFindingsOutput{} 3265 out.Result = output 3266 3267 var buff [1024]byte 3268 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3269 3270 body := io.TeeReader(response.Body, ringBuffer) 3271 3272 decoder := json.NewDecoder(body) 3273 decoder.UseNumber() 3274 var shape interface{} 3275 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3276 var snapshot bytes.Buffer 3277 io.Copy(&snapshot, ringBuffer) 3278 err = &smithy.DeserializationError{ 3279 Err: fmt.Errorf("failed to decode response body, %w", err), 3280 Snapshot: snapshot.Bytes(), 3281 } 3282 return out, metadata, err 3283 } 3284 3285 err = awsRestjson1_deserializeOpDocumentGetFindingsOutput(&output, shape) 3286 if err != nil { 3287 var snapshot bytes.Buffer 3288 io.Copy(&snapshot, ringBuffer) 3289 return out, metadata, &smithy.DeserializationError{ 3290 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3291 Snapshot: snapshot.Bytes(), 3292 } 3293 } 3294 3295 return out, metadata, err 3296} 3297 3298func awsRestjson1_deserializeOpErrorGetFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3299 var errorBuffer bytes.Buffer 3300 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3301 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3302 } 3303 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3304 3305 errorCode := "UnknownError" 3306 errorMessage := errorCode 3307 3308 code := response.Header.Get("X-Amzn-ErrorType") 3309 if len(code) != 0 { 3310 errorCode = restjson.SanitizeErrorCode(code) 3311 } 3312 3313 var buff [1024]byte 3314 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3315 3316 body := io.TeeReader(errorBody, ringBuffer) 3317 decoder := json.NewDecoder(body) 3318 decoder.UseNumber() 3319 code, message, err := restjson.GetErrorInfo(decoder) 3320 if err != nil { 3321 var snapshot bytes.Buffer 3322 io.Copy(&snapshot, ringBuffer) 3323 err = &smithy.DeserializationError{ 3324 Err: fmt.Errorf("failed to decode response body, %w", err), 3325 Snapshot: snapshot.Bytes(), 3326 } 3327 return err 3328 } 3329 3330 errorBody.Seek(0, io.SeekStart) 3331 if len(code) != 0 { 3332 errorCode = restjson.SanitizeErrorCode(code) 3333 } 3334 if len(message) != 0 { 3335 errorMessage = message 3336 } 3337 3338 switch { 3339 case strings.EqualFold("BadRequestException", errorCode): 3340 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3341 3342 case strings.EqualFold("InternalServerErrorException", errorCode): 3343 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3344 3345 default: 3346 genericError := &smithy.GenericAPIError{ 3347 Code: errorCode, 3348 Message: errorMessage, 3349 } 3350 return genericError 3351 3352 } 3353} 3354 3355func awsRestjson1_deserializeOpDocumentGetFindingsOutput(v **GetFindingsOutput, value interface{}) error { 3356 if v == nil { 3357 return fmt.Errorf("unexpected nil of type %T", v) 3358 } 3359 if value == nil { 3360 return nil 3361 } 3362 3363 shape, ok := value.(map[string]interface{}) 3364 if !ok { 3365 return fmt.Errorf("unexpected JSON type %v", value) 3366 } 3367 3368 var sv *GetFindingsOutput 3369 if *v == nil { 3370 sv = &GetFindingsOutput{} 3371 } else { 3372 sv = *v 3373 } 3374 3375 for key, value := range shape { 3376 switch key { 3377 case "findings": 3378 if err := awsRestjson1_deserializeDocumentFindings(&sv.Findings, value); err != nil { 3379 return err 3380 } 3381 3382 default: 3383 _, _ = key, value 3384 3385 } 3386 } 3387 *v = sv 3388 return nil 3389} 3390 3391type awsRestjson1_deserializeOpGetFindingsStatistics struct { 3392} 3393 3394func (*awsRestjson1_deserializeOpGetFindingsStatistics) ID() string { 3395 return "OperationDeserializer" 3396} 3397 3398func (m *awsRestjson1_deserializeOpGetFindingsStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3399 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3400) { 3401 out, metadata, err = next.HandleDeserialize(ctx, in) 3402 if err != nil { 3403 return out, metadata, err 3404 } 3405 3406 response, ok := out.RawResponse.(*smithyhttp.Response) 3407 if !ok { 3408 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3409 } 3410 3411 if response.StatusCode < 200 || response.StatusCode >= 300 { 3412 return out, metadata, awsRestjson1_deserializeOpErrorGetFindingsStatistics(response, &metadata) 3413 } 3414 output := &GetFindingsStatisticsOutput{} 3415 out.Result = output 3416 3417 var buff [1024]byte 3418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3419 3420 body := io.TeeReader(response.Body, ringBuffer) 3421 3422 decoder := json.NewDecoder(body) 3423 decoder.UseNumber() 3424 var shape interface{} 3425 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3426 var snapshot bytes.Buffer 3427 io.Copy(&snapshot, ringBuffer) 3428 err = &smithy.DeserializationError{ 3429 Err: fmt.Errorf("failed to decode response body, %w", err), 3430 Snapshot: snapshot.Bytes(), 3431 } 3432 return out, metadata, err 3433 } 3434 3435 err = awsRestjson1_deserializeOpDocumentGetFindingsStatisticsOutput(&output, shape) 3436 if err != nil { 3437 var snapshot bytes.Buffer 3438 io.Copy(&snapshot, ringBuffer) 3439 return out, metadata, &smithy.DeserializationError{ 3440 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3441 Snapshot: snapshot.Bytes(), 3442 } 3443 } 3444 3445 return out, metadata, err 3446} 3447 3448func awsRestjson1_deserializeOpErrorGetFindingsStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3449 var errorBuffer bytes.Buffer 3450 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3451 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3452 } 3453 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3454 3455 errorCode := "UnknownError" 3456 errorMessage := errorCode 3457 3458 code := response.Header.Get("X-Amzn-ErrorType") 3459 if len(code) != 0 { 3460 errorCode = restjson.SanitizeErrorCode(code) 3461 } 3462 3463 var buff [1024]byte 3464 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3465 3466 body := io.TeeReader(errorBody, ringBuffer) 3467 decoder := json.NewDecoder(body) 3468 decoder.UseNumber() 3469 code, message, err := restjson.GetErrorInfo(decoder) 3470 if err != nil { 3471 var snapshot bytes.Buffer 3472 io.Copy(&snapshot, ringBuffer) 3473 err = &smithy.DeserializationError{ 3474 Err: fmt.Errorf("failed to decode response body, %w", err), 3475 Snapshot: snapshot.Bytes(), 3476 } 3477 return err 3478 } 3479 3480 errorBody.Seek(0, io.SeekStart) 3481 if len(code) != 0 { 3482 errorCode = restjson.SanitizeErrorCode(code) 3483 } 3484 if len(message) != 0 { 3485 errorMessage = message 3486 } 3487 3488 switch { 3489 case strings.EqualFold("BadRequestException", errorCode): 3490 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3491 3492 case strings.EqualFold("InternalServerErrorException", errorCode): 3493 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3494 3495 default: 3496 genericError := &smithy.GenericAPIError{ 3497 Code: errorCode, 3498 Message: errorMessage, 3499 } 3500 return genericError 3501 3502 } 3503} 3504 3505func awsRestjson1_deserializeOpDocumentGetFindingsStatisticsOutput(v **GetFindingsStatisticsOutput, value interface{}) error { 3506 if v == nil { 3507 return fmt.Errorf("unexpected nil of type %T", v) 3508 } 3509 if value == nil { 3510 return nil 3511 } 3512 3513 shape, ok := value.(map[string]interface{}) 3514 if !ok { 3515 return fmt.Errorf("unexpected JSON type %v", value) 3516 } 3517 3518 var sv *GetFindingsStatisticsOutput 3519 if *v == nil { 3520 sv = &GetFindingsStatisticsOutput{} 3521 } else { 3522 sv = *v 3523 } 3524 3525 for key, value := range shape { 3526 switch key { 3527 case "findingStatistics": 3528 if err := awsRestjson1_deserializeDocumentFindingStatistics(&sv.FindingStatistics, value); err != nil { 3529 return err 3530 } 3531 3532 default: 3533 _, _ = key, value 3534 3535 } 3536 } 3537 *v = sv 3538 return nil 3539} 3540 3541type awsRestjson1_deserializeOpGetInvitationsCount struct { 3542} 3543 3544func (*awsRestjson1_deserializeOpGetInvitationsCount) ID() string { 3545 return "OperationDeserializer" 3546} 3547 3548func (m *awsRestjson1_deserializeOpGetInvitationsCount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3549 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3550) { 3551 out, metadata, err = next.HandleDeserialize(ctx, in) 3552 if err != nil { 3553 return out, metadata, err 3554 } 3555 3556 response, ok := out.RawResponse.(*smithyhttp.Response) 3557 if !ok { 3558 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3559 } 3560 3561 if response.StatusCode < 200 || response.StatusCode >= 300 { 3562 return out, metadata, awsRestjson1_deserializeOpErrorGetInvitationsCount(response, &metadata) 3563 } 3564 output := &GetInvitationsCountOutput{} 3565 out.Result = output 3566 3567 var buff [1024]byte 3568 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3569 3570 body := io.TeeReader(response.Body, ringBuffer) 3571 3572 decoder := json.NewDecoder(body) 3573 decoder.UseNumber() 3574 var shape interface{} 3575 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3576 var snapshot bytes.Buffer 3577 io.Copy(&snapshot, ringBuffer) 3578 err = &smithy.DeserializationError{ 3579 Err: fmt.Errorf("failed to decode response body, %w", err), 3580 Snapshot: snapshot.Bytes(), 3581 } 3582 return out, metadata, err 3583 } 3584 3585 err = awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(&output, shape) 3586 if err != nil { 3587 var snapshot bytes.Buffer 3588 io.Copy(&snapshot, ringBuffer) 3589 return out, metadata, &smithy.DeserializationError{ 3590 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3591 Snapshot: snapshot.Bytes(), 3592 } 3593 } 3594 3595 return out, metadata, err 3596} 3597 3598func awsRestjson1_deserializeOpErrorGetInvitationsCount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3599 var errorBuffer bytes.Buffer 3600 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3601 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3602 } 3603 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3604 3605 errorCode := "UnknownError" 3606 errorMessage := errorCode 3607 3608 code := response.Header.Get("X-Amzn-ErrorType") 3609 if len(code) != 0 { 3610 errorCode = restjson.SanitizeErrorCode(code) 3611 } 3612 3613 var buff [1024]byte 3614 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3615 3616 body := io.TeeReader(errorBody, ringBuffer) 3617 decoder := json.NewDecoder(body) 3618 decoder.UseNumber() 3619 code, message, err := restjson.GetErrorInfo(decoder) 3620 if err != nil { 3621 var snapshot bytes.Buffer 3622 io.Copy(&snapshot, ringBuffer) 3623 err = &smithy.DeserializationError{ 3624 Err: fmt.Errorf("failed to decode response body, %w", err), 3625 Snapshot: snapshot.Bytes(), 3626 } 3627 return err 3628 } 3629 3630 errorBody.Seek(0, io.SeekStart) 3631 if len(code) != 0 { 3632 errorCode = restjson.SanitizeErrorCode(code) 3633 } 3634 if len(message) != 0 { 3635 errorMessage = message 3636 } 3637 3638 switch { 3639 case strings.EqualFold("BadRequestException", errorCode): 3640 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3641 3642 case strings.EqualFold("InternalServerErrorException", errorCode): 3643 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3644 3645 default: 3646 genericError := &smithy.GenericAPIError{ 3647 Code: errorCode, 3648 Message: errorMessage, 3649 } 3650 return genericError 3651 3652 } 3653} 3654 3655func awsRestjson1_deserializeOpDocumentGetInvitationsCountOutput(v **GetInvitationsCountOutput, value interface{}) error { 3656 if v == nil { 3657 return fmt.Errorf("unexpected nil of type %T", v) 3658 } 3659 if value == nil { 3660 return nil 3661 } 3662 3663 shape, ok := value.(map[string]interface{}) 3664 if !ok { 3665 return fmt.Errorf("unexpected JSON type %v", value) 3666 } 3667 3668 var sv *GetInvitationsCountOutput 3669 if *v == nil { 3670 sv = &GetInvitationsCountOutput{} 3671 } else { 3672 sv = *v 3673 } 3674 3675 for key, value := range shape { 3676 switch key { 3677 case "invitationsCount": 3678 if value != nil { 3679 jtv, ok := value.(json.Number) 3680 if !ok { 3681 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 3682 } 3683 i64, err := jtv.Int64() 3684 if err != nil { 3685 return err 3686 } 3687 sv.InvitationsCount = int32(i64) 3688 } 3689 3690 default: 3691 _, _ = key, value 3692 3693 } 3694 } 3695 *v = sv 3696 return nil 3697} 3698 3699type awsRestjson1_deserializeOpGetIPSet struct { 3700} 3701 3702func (*awsRestjson1_deserializeOpGetIPSet) ID() string { 3703 return "OperationDeserializer" 3704} 3705 3706func (m *awsRestjson1_deserializeOpGetIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3707 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3708) { 3709 out, metadata, err = next.HandleDeserialize(ctx, in) 3710 if err != nil { 3711 return out, metadata, err 3712 } 3713 3714 response, ok := out.RawResponse.(*smithyhttp.Response) 3715 if !ok { 3716 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3717 } 3718 3719 if response.StatusCode < 200 || response.StatusCode >= 300 { 3720 return out, metadata, awsRestjson1_deserializeOpErrorGetIPSet(response, &metadata) 3721 } 3722 output := &GetIPSetOutput{} 3723 out.Result = output 3724 3725 var buff [1024]byte 3726 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3727 3728 body := io.TeeReader(response.Body, ringBuffer) 3729 3730 decoder := json.NewDecoder(body) 3731 decoder.UseNumber() 3732 var shape interface{} 3733 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3734 var snapshot bytes.Buffer 3735 io.Copy(&snapshot, ringBuffer) 3736 err = &smithy.DeserializationError{ 3737 Err: fmt.Errorf("failed to decode response body, %w", err), 3738 Snapshot: snapshot.Bytes(), 3739 } 3740 return out, metadata, err 3741 } 3742 3743 err = awsRestjson1_deserializeOpDocumentGetIPSetOutput(&output, shape) 3744 if err != nil { 3745 var snapshot bytes.Buffer 3746 io.Copy(&snapshot, ringBuffer) 3747 return out, metadata, &smithy.DeserializationError{ 3748 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3749 Snapshot: snapshot.Bytes(), 3750 } 3751 } 3752 3753 return out, metadata, err 3754} 3755 3756func awsRestjson1_deserializeOpErrorGetIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3757 var errorBuffer bytes.Buffer 3758 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3759 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3760 } 3761 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3762 3763 errorCode := "UnknownError" 3764 errorMessage := errorCode 3765 3766 code := response.Header.Get("X-Amzn-ErrorType") 3767 if len(code) != 0 { 3768 errorCode = restjson.SanitizeErrorCode(code) 3769 } 3770 3771 var buff [1024]byte 3772 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3773 3774 body := io.TeeReader(errorBody, ringBuffer) 3775 decoder := json.NewDecoder(body) 3776 decoder.UseNumber() 3777 code, message, err := restjson.GetErrorInfo(decoder) 3778 if err != nil { 3779 var snapshot bytes.Buffer 3780 io.Copy(&snapshot, ringBuffer) 3781 err = &smithy.DeserializationError{ 3782 Err: fmt.Errorf("failed to decode response body, %w", err), 3783 Snapshot: snapshot.Bytes(), 3784 } 3785 return err 3786 } 3787 3788 errorBody.Seek(0, io.SeekStart) 3789 if len(code) != 0 { 3790 errorCode = restjson.SanitizeErrorCode(code) 3791 } 3792 if len(message) != 0 { 3793 errorMessage = message 3794 } 3795 3796 switch { 3797 case strings.EqualFold("BadRequestException", errorCode): 3798 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3799 3800 case strings.EqualFold("InternalServerErrorException", errorCode): 3801 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3802 3803 default: 3804 genericError := &smithy.GenericAPIError{ 3805 Code: errorCode, 3806 Message: errorMessage, 3807 } 3808 return genericError 3809 3810 } 3811} 3812 3813func awsRestjson1_deserializeOpDocumentGetIPSetOutput(v **GetIPSetOutput, value interface{}) error { 3814 if v == nil { 3815 return fmt.Errorf("unexpected nil of type %T", v) 3816 } 3817 if value == nil { 3818 return nil 3819 } 3820 3821 shape, ok := value.(map[string]interface{}) 3822 if !ok { 3823 return fmt.Errorf("unexpected JSON type %v", value) 3824 } 3825 3826 var sv *GetIPSetOutput 3827 if *v == nil { 3828 sv = &GetIPSetOutput{} 3829 } else { 3830 sv = *v 3831 } 3832 3833 for key, value := range shape { 3834 switch key { 3835 case "format": 3836 if value != nil { 3837 jtv, ok := value.(string) 3838 if !ok { 3839 return fmt.Errorf("expected IpSetFormat to be of type string, got %T instead", value) 3840 } 3841 sv.Format = types.IpSetFormat(jtv) 3842 } 3843 3844 case "location": 3845 if value != nil { 3846 jtv, ok := value.(string) 3847 if !ok { 3848 return fmt.Errorf("expected Location to be of type string, got %T instead", value) 3849 } 3850 sv.Location = ptr.String(jtv) 3851 } 3852 3853 case "name": 3854 if value != nil { 3855 jtv, ok := value.(string) 3856 if !ok { 3857 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 3858 } 3859 sv.Name = ptr.String(jtv) 3860 } 3861 3862 case "status": 3863 if value != nil { 3864 jtv, ok := value.(string) 3865 if !ok { 3866 return fmt.Errorf("expected IpSetStatus to be of type string, got %T instead", value) 3867 } 3868 sv.Status = types.IpSetStatus(jtv) 3869 } 3870 3871 case "tags": 3872 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 3873 return err 3874 } 3875 3876 default: 3877 _, _ = key, value 3878 3879 } 3880 } 3881 *v = sv 3882 return nil 3883} 3884 3885type awsRestjson1_deserializeOpGetMasterAccount struct { 3886} 3887 3888func (*awsRestjson1_deserializeOpGetMasterAccount) ID() string { 3889 return "OperationDeserializer" 3890} 3891 3892func (m *awsRestjson1_deserializeOpGetMasterAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3893 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3894) { 3895 out, metadata, err = next.HandleDeserialize(ctx, in) 3896 if err != nil { 3897 return out, metadata, err 3898 } 3899 3900 response, ok := out.RawResponse.(*smithyhttp.Response) 3901 if !ok { 3902 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3903 } 3904 3905 if response.StatusCode < 200 || response.StatusCode >= 300 { 3906 return out, metadata, awsRestjson1_deserializeOpErrorGetMasterAccount(response, &metadata) 3907 } 3908 output := &GetMasterAccountOutput{} 3909 out.Result = output 3910 3911 var buff [1024]byte 3912 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3913 3914 body := io.TeeReader(response.Body, ringBuffer) 3915 3916 decoder := json.NewDecoder(body) 3917 decoder.UseNumber() 3918 var shape interface{} 3919 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3920 var snapshot bytes.Buffer 3921 io.Copy(&snapshot, ringBuffer) 3922 err = &smithy.DeserializationError{ 3923 Err: fmt.Errorf("failed to decode response body, %w", err), 3924 Snapshot: snapshot.Bytes(), 3925 } 3926 return out, metadata, err 3927 } 3928 3929 err = awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(&output, shape) 3930 if err != nil { 3931 var snapshot bytes.Buffer 3932 io.Copy(&snapshot, ringBuffer) 3933 return out, metadata, &smithy.DeserializationError{ 3934 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3935 Snapshot: snapshot.Bytes(), 3936 } 3937 } 3938 3939 return out, metadata, err 3940} 3941 3942func awsRestjson1_deserializeOpErrorGetMasterAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3943 var errorBuffer bytes.Buffer 3944 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3945 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3946 } 3947 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3948 3949 errorCode := "UnknownError" 3950 errorMessage := errorCode 3951 3952 code := response.Header.Get("X-Amzn-ErrorType") 3953 if len(code) != 0 { 3954 errorCode = restjson.SanitizeErrorCode(code) 3955 } 3956 3957 var buff [1024]byte 3958 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3959 3960 body := io.TeeReader(errorBody, ringBuffer) 3961 decoder := json.NewDecoder(body) 3962 decoder.UseNumber() 3963 code, message, err := restjson.GetErrorInfo(decoder) 3964 if err != nil { 3965 var snapshot bytes.Buffer 3966 io.Copy(&snapshot, ringBuffer) 3967 err = &smithy.DeserializationError{ 3968 Err: fmt.Errorf("failed to decode response body, %w", err), 3969 Snapshot: snapshot.Bytes(), 3970 } 3971 return err 3972 } 3973 3974 errorBody.Seek(0, io.SeekStart) 3975 if len(code) != 0 { 3976 errorCode = restjson.SanitizeErrorCode(code) 3977 } 3978 if len(message) != 0 { 3979 errorMessage = message 3980 } 3981 3982 switch { 3983 case strings.EqualFold("BadRequestException", errorCode): 3984 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 3985 3986 case strings.EqualFold("InternalServerErrorException", errorCode): 3987 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 3988 3989 default: 3990 genericError := &smithy.GenericAPIError{ 3991 Code: errorCode, 3992 Message: errorMessage, 3993 } 3994 return genericError 3995 3996 } 3997} 3998 3999func awsRestjson1_deserializeOpDocumentGetMasterAccountOutput(v **GetMasterAccountOutput, value interface{}) error { 4000 if v == nil { 4001 return fmt.Errorf("unexpected nil of type %T", v) 4002 } 4003 if value == nil { 4004 return nil 4005 } 4006 4007 shape, ok := value.(map[string]interface{}) 4008 if !ok { 4009 return fmt.Errorf("unexpected JSON type %v", value) 4010 } 4011 4012 var sv *GetMasterAccountOutput 4013 if *v == nil { 4014 sv = &GetMasterAccountOutput{} 4015 } else { 4016 sv = *v 4017 } 4018 4019 for key, value := range shape { 4020 switch key { 4021 case "master": 4022 if err := awsRestjson1_deserializeDocumentMaster(&sv.Master, value); err != nil { 4023 return err 4024 } 4025 4026 default: 4027 _, _ = key, value 4028 4029 } 4030 } 4031 *v = sv 4032 return nil 4033} 4034 4035type awsRestjson1_deserializeOpGetMemberDetectors struct { 4036} 4037 4038func (*awsRestjson1_deserializeOpGetMemberDetectors) ID() string { 4039 return "OperationDeserializer" 4040} 4041 4042func (m *awsRestjson1_deserializeOpGetMemberDetectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4043 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4044) { 4045 out, metadata, err = next.HandleDeserialize(ctx, in) 4046 if err != nil { 4047 return out, metadata, err 4048 } 4049 4050 response, ok := out.RawResponse.(*smithyhttp.Response) 4051 if !ok { 4052 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4053 } 4054 4055 if response.StatusCode < 200 || response.StatusCode >= 300 { 4056 return out, metadata, awsRestjson1_deserializeOpErrorGetMemberDetectors(response, &metadata) 4057 } 4058 output := &GetMemberDetectorsOutput{} 4059 out.Result = output 4060 4061 var buff [1024]byte 4062 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4063 4064 body := io.TeeReader(response.Body, ringBuffer) 4065 4066 decoder := json.NewDecoder(body) 4067 decoder.UseNumber() 4068 var shape interface{} 4069 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4070 var snapshot bytes.Buffer 4071 io.Copy(&snapshot, ringBuffer) 4072 err = &smithy.DeserializationError{ 4073 Err: fmt.Errorf("failed to decode response body, %w", err), 4074 Snapshot: snapshot.Bytes(), 4075 } 4076 return out, metadata, err 4077 } 4078 4079 err = awsRestjson1_deserializeOpDocumentGetMemberDetectorsOutput(&output, shape) 4080 if err != nil { 4081 var snapshot bytes.Buffer 4082 io.Copy(&snapshot, ringBuffer) 4083 return out, metadata, &smithy.DeserializationError{ 4084 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4085 Snapshot: snapshot.Bytes(), 4086 } 4087 } 4088 4089 return out, metadata, err 4090} 4091 4092func awsRestjson1_deserializeOpErrorGetMemberDetectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4093 var errorBuffer bytes.Buffer 4094 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4095 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4096 } 4097 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4098 4099 errorCode := "UnknownError" 4100 errorMessage := errorCode 4101 4102 code := response.Header.Get("X-Amzn-ErrorType") 4103 if len(code) != 0 { 4104 errorCode = restjson.SanitizeErrorCode(code) 4105 } 4106 4107 var buff [1024]byte 4108 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4109 4110 body := io.TeeReader(errorBody, ringBuffer) 4111 decoder := json.NewDecoder(body) 4112 decoder.UseNumber() 4113 code, message, err := restjson.GetErrorInfo(decoder) 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 if len(code) != 0 { 4126 errorCode = restjson.SanitizeErrorCode(code) 4127 } 4128 if len(message) != 0 { 4129 errorMessage = message 4130 } 4131 4132 switch { 4133 case strings.EqualFold("BadRequestException", errorCode): 4134 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4135 4136 case strings.EqualFold("InternalServerErrorException", errorCode): 4137 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4138 4139 default: 4140 genericError := &smithy.GenericAPIError{ 4141 Code: errorCode, 4142 Message: errorMessage, 4143 } 4144 return genericError 4145 4146 } 4147} 4148 4149func awsRestjson1_deserializeOpDocumentGetMemberDetectorsOutput(v **GetMemberDetectorsOutput, value interface{}) error { 4150 if v == nil { 4151 return fmt.Errorf("unexpected nil of type %T", v) 4152 } 4153 if value == nil { 4154 return nil 4155 } 4156 4157 shape, ok := value.(map[string]interface{}) 4158 if !ok { 4159 return fmt.Errorf("unexpected JSON type %v", value) 4160 } 4161 4162 var sv *GetMemberDetectorsOutput 4163 if *v == nil { 4164 sv = &GetMemberDetectorsOutput{} 4165 } else { 4166 sv = *v 4167 } 4168 4169 for key, value := range shape { 4170 switch key { 4171 case "members": 4172 if err := awsRestjson1_deserializeDocumentMemberDataSourceConfigurations(&sv.MemberDataSourceConfigurations, value); err != nil { 4173 return err 4174 } 4175 4176 case "unprocessedAccounts": 4177 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 4178 return err 4179 } 4180 4181 default: 4182 _, _ = key, value 4183 4184 } 4185 } 4186 *v = sv 4187 return nil 4188} 4189 4190type awsRestjson1_deserializeOpGetMembers struct { 4191} 4192 4193func (*awsRestjson1_deserializeOpGetMembers) ID() string { 4194 return "OperationDeserializer" 4195} 4196 4197func (m *awsRestjson1_deserializeOpGetMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4198 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4199) { 4200 out, metadata, err = next.HandleDeserialize(ctx, in) 4201 if err != nil { 4202 return out, metadata, err 4203 } 4204 4205 response, ok := out.RawResponse.(*smithyhttp.Response) 4206 if !ok { 4207 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4208 } 4209 4210 if response.StatusCode < 200 || response.StatusCode >= 300 { 4211 return out, metadata, awsRestjson1_deserializeOpErrorGetMembers(response, &metadata) 4212 } 4213 output := &GetMembersOutput{} 4214 out.Result = output 4215 4216 var buff [1024]byte 4217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4218 4219 body := io.TeeReader(response.Body, ringBuffer) 4220 4221 decoder := json.NewDecoder(body) 4222 decoder.UseNumber() 4223 var shape interface{} 4224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4225 var snapshot bytes.Buffer 4226 io.Copy(&snapshot, ringBuffer) 4227 err = &smithy.DeserializationError{ 4228 Err: fmt.Errorf("failed to decode response body, %w", err), 4229 Snapshot: snapshot.Bytes(), 4230 } 4231 return out, metadata, err 4232 } 4233 4234 err = awsRestjson1_deserializeOpDocumentGetMembersOutput(&output, shape) 4235 if err != nil { 4236 var snapshot bytes.Buffer 4237 io.Copy(&snapshot, ringBuffer) 4238 return out, metadata, &smithy.DeserializationError{ 4239 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4240 Snapshot: snapshot.Bytes(), 4241 } 4242 } 4243 4244 return out, metadata, err 4245} 4246 4247func awsRestjson1_deserializeOpErrorGetMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4248 var errorBuffer bytes.Buffer 4249 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4250 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4251 } 4252 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4253 4254 errorCode := "UnknownError" 4255 errorMessage := errorCode 4256 4257 code := response.Header.Get("X-Amzn-ErrorType") 4258 if len(code) != 0 { 4259 errorCode = restjson.SanitizeErrorCode(code) 4260 } 4261 4262 var buff [1024]byte 4263 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4264 4265 body := io.TeeReader(errorBody, ringBuffer) 4266 decoder := json.NewDecoder(body) 4267 decoder.UseNumber() 4268 code, message, err := restjson.GetErrorInfo(decoder) 4269 if err != nil { 4270 var snapshot bytes.Buffer 4271 io.Copy(&snapshot, ringBuffer) 4272 err = &smithy.DeserializationError{ 4273 Err: fmt.Errorf("failed to decode response body, %w", err), 4274 Snapshot: snapshot.Bytes(), 4275 } 4276 return err 4277 } 4278 4279 errorBody.Seek(0, io.SeekStart) 4280 if len(code) != 0 { 4281 errorCode = restjson.SanitizeErrorCode(code) 4282 } 4283 if len(message) != 0 { 4284 errorMessage = message 4285 } 4286 4287 switch { 4288 case strings.EqualFold("BadRequestException", errorCode): 4289 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4290 4291 case strings.EqualFold("InternalServerErrorException", errorCode): 4292 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4293 4294 default: 4295 genericError := &smithy.GenericAPIError{ 4296 Code: errorCode, 4297 Message: errorMessage, 4298 } 4299 return genericError 4300 4301 } 4302} 4303 4304func awsRestjson1_deserializeOpDocumentGetMembersOutput(v **GetMembersOutput, value interface{}) error { 4305 if v == nil { 4306 return fmt.Errorf("unexpected nil of type %T", v) 4307 } 4308 if value == nil { 4309 return nil 4310 } 4311 4312 shape, ok := value.(map[string]interface{}) 4313 if !ok { 4314 return fmt.Errorf("unexpected JSON type %v", value) 4315 } 4316 4317 var sv *GetMembersOutput 4318 if *v == nil { 4319 sv = &GetMembersOutput{} 4320 } else { 4321 sv = *v 4322 } 4323 4324 for key, value := range shape { 4325 switch key { 4326 case "members": 4327 if err := awsRestjson1_deserializeDocumentMembers(&sv.Members, value); err != nil { 4328 return err 4329 } 4330 4331 case "unprocessedAccounts": 4332 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 4333 return err 4334 } 4335 4336 default: 4337 _, _ = key, value 4338 4339 } 4340 } 4341 *v = sv 4342 return nil 4343} 4344 4345type awsRestjson1_deserializeOpGetThreatIntelSet struct { 4346} 4347 4348func (*awsRestjson1_deserializeOpGetThreatIntelSet) ID() string { 4349 return "OperationDeserializer" 4350} 4351 4352func (m *awsRestjson1_deserializeOpGetThreatIntelSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4353 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4354) { 4355 out, metadata, err = next.HandleDeserialize(ctx, in) 4356 if err != nil { 4357 return out, metadata, err 4358 } 4359 4360 response, ok := out.RawResponse.(*smithyhttp.Response) 4361 if !ok { 4362 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4363 } 4364 4365 if response.StatusCode < 200 || response.StatusCode >= 300 { 4366 return out, metadata, awsRestjson1_deserializeOpErrorGetThreatIntelSet(response, &metadata) 4367 } 4368 output := &GetThreatIntelSetOutput{} 4369 out.Result = output 4370 4371 var buff [1024]byte 4372 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4373 4374 body := io.TeeReader(response.Body, ringBuffer) 4375 4376 decoder := json.NewDecoder(body) 4377 decoder.UseNumber() 4378 var shape interface{} 4379 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4380 var snapshot bytes.Buffer 4381 io.Copy(&snapshot, ringBuffer) 4382 err = &smithy.DeserializationError{ 4383 Err: fmt.Errorf("failed to decode response body, %w", err), 4384 Snapshot: snapshot.Bytes(), 4385 } 4386 return out, metadata, err 4387 } 4388 4389 err = awsRestjson1_deserializeOpDocumentGetThreatIntelSetOutput(&output, shape) 4390 if err != nil { 4391 var snapshot bytes.Buffer 4392 io.Copy(&snapshot, ringBuffer) 4393 return out, metadata, &smithy.DeserializationError{ 4394 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4395 Snapshot: snapshot.Bytes(), 4396 } 4397 } 4398 4399 return out, metadata, err 4400} 4401 4402func awsRestjson1_deserializeOpErrorGetThreatIntelSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4403 var errorBuffer bytes.Buffer 4404 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4405 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4406 } 4407 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4408 4409 errorCode := "UnknownError" 4410 errorMessage := errorCode 4411 4412 code := response.Header.Get("X-Amzn-ErrorType") 4413 if len(code) != 0 { 4414 errorCode = restjson.SanitizeErrorCode(code) 4415 } 4416 4417 var buff [1024]byte 4418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4419 4420 body := io.TeeReader(errorBody, ringBuffer) 4421 decoder := json.NewDecoder(body) 4422 decoder.UseNumber() 4423 code, message, err := restjson.GetErrorInfo(decoder) 4424 if err != nil { 4425 var snapshot bytes.Buffer 4426 io.Copy(&snapshot, ringBuffer) 4427 err = &smithy.DeserializationError{ 4428 Err: fmt.Errorf("failed to decode response body, %w", err), 4429 Snapshot: snapshot.Bytes(), 4430 } 4431 return err 4432 } 4433 4434 errorBody.Seek(0, io.SeekStart) 4435 if len(code) != 0 { 4436 errorCode = restjson.SanitizeErrorCode(code) 4437 } 4438 if len(message) != 0 { 4439 errorMessage = message 4440 } 4441 4442 switch { 4443 case strings.EqualFold("BadRequestException", errorCode): 4444 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4445 4446 case strings.EqualFold("InternalServerErrorException", errorCode): 4447 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4448 4449 default: 4450 genericError := &smithy.GenericAPIError{ 4451 Code: errorCode, 4452 Message: errorMessage, 4453 } 4454 return genericError 4455 4456 } 4457} 4458 4459func awsRestjson1_deserializeOpDocumentGetThreatIntelSetOutput(v **GetThreatIntelSetOutput, value interface{}) error { 4460 if v == nil { 4461 return fmt.Errorf("unexpected nil of type %T", v) 4462 } 4463 if value == nil { 4464 return nil 4465 } 4466 4467 shape, ok := value.(map[string]interface{}) 4468 if !ok { 4469 return fmt.Errorf("unexpected JSON type %v", value) 4470 } 4471 4472 var sv *GetThreatIntelSetOutput 4473 if *v == nil { 4474 sv = &GetThreatIntelSetOutput{} 4475 } else { 4476 sv = *v 4477 } 4478 4479 for key, value := range shape { 4480 switch key { 4481 case "format": 4482 if value != nil { 4483 jtv, ok := value.(string) 4484 if !ok { 4485 return fmt.Errorf("expected ThreatIntelSetFormat to be of type string, got %T instead", value) 4486 } 4487 sv.Format = types.ThreatIntelSetFormat(jtv) 4488 } 4489 4490 case "location": 4491 if value != nil { 4492 jtv, ok := value.(string) 4493 if !ok { 4494 return fmt.Errorf("expected Location to be of type string, got %T instead", value) 4495 } 4496 sv.Location = ptr.String(jtv) 4497 } 4498 4499 case "name": 4500 if value != nil { 4501 jtv, ok := value.(string) 4502 if !ok { 4503 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 4504 } 4505 sv.Name = ptr.String(jtv) 4506 } 4507 4508 case "status": 4509 if value != nil { 4510 jtv, ok := value.(string) 4511 if !ok { 4512 return fmt.Errorf("expected ThreatIntelSetStatus to be of type string, got %T instead", value) 4513 } 4514 sv.Status = types.ThreatIntelSetStatus(jtv) 4515 } 4516 4517 case "tags": 4518 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 4519 return err 4520 } 4521 4522 default: 4523 _, _ = key, value 4524 4525 } 4526 } 4527 *v = sv 4528 return nil 4529} 4530 4531type awsRestjson1_deserializeOpGetUsageStatistics struct { 4532} 4533 4534func (*awsRestjson1_deserializeOpGetUsageStatistics) ID() string { 4535 return "OperationDeserializer" 4536} 4537 4538func (m *awsRestjson1_deserializeOpGetUsageStatistics) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4539 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4540) { 4541 out, metadata, err = next.HandleDeserialize(ctx, in) 4542 if err != nil { 4543 return out, metadata, err 4544 } 4545 4546 response, ok := out.RawResponse.(*smithyhttp.Response) 4547 if !ok { 4548 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4549 } 4550 4551 if response.StatusCode < 200 || response.StatusCode >= 300 { 4552 return out, metadata, awsRestjson1_deserializeOpErrorGetUsageStatistics(response, &metadata) 4553 } 4554 output := &GetUsageStatisticsOutput{} 4555 out.Result = output 4556 4557 var buff [1024]byte 4558 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4559 4560 body := io.TeeReader(response.Body, ringBuffer) 4561 4562 decoder := json.NewDecoder(body) 4563 decoder.UseNumber() 4564 var shape interface{} 4565 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4566 var snapshot bytes.Buffer 4567 io.Copy(&snapshot, ringBuffer) 4568 err = &smithy.DeserializationError{ 4569 Err: fmt.Errorf("failed to decode response body, %w", err), 4570 Snapshot: snapshot.Bytes(), 4571 } 4572 return out, metadata, err 4573 } 4574 4575 err = awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(&output, shape) 4576 if err != nil { 4577 var snapshot bytes.Buffer 4578 io.Copy(&snapshot, ringBuffer) 4579 return out, metadata, &smithy.DeserializationError{ 4580 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4581 Snapshot: snapshot.Bytes(), 4582 } 4583 } 4584 4585 return out, metadata, err 4586} 4587 4588func awsRestjson1_deserializeOpErrorGetUsageStatistics(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4589 var errorBuffer bytes.Buffer 4590 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4591 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4592 } 4593 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4594 4595 errorCode := "UnknownError" 4596 errorMessage := errorCode 4597 4598 code := response.Header.Get("X-Amzn-ErrorType") 4599 if len(code) != 0 { 4600 errorCode = restjson.SanitizeErrorCode(code) 4601 } 4602 4603 var buff [1024]byte 4604 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4605 4606 body := io.TeeReader(errorBody, ringBuffer) 4607 decoder := json.NewDecoder(body) 4608 decoder.UseNumber() 4609 code, message, err := restjson.GetErrorInfo(decoder) 4610 if err != nil { 4611 var snapshot bytes.Buffer 4612 io.Copy(&snapshot, ringBuffer) 4613 err = &smithy.DeserializationError{ 4614 Err: fmt.Errorf("failed to decode response body, %w", err), 4615 Snapshot: snapshot.Bytes(), 4616 } 4617 return err 4618 } 4619 4620 errorBody.Seek(0, io.SeekStart) 4621 if len(code) != 0 { 4622 errorCode = restjson.SanitizeErrorCode(code) 4623 } 4624 if len(message) != 0 { 4625 errorMessage = message 4626 } 4627 4628 switch { 4629 case strings.EqualFold("BadRequestException", errorCode): 4630 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4631 4632 case strings.EqualFold("InternalServerErrorException", errorCode): 4633 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4634 4635 default: 4636 genericError := &smithy.GenericAPIError{ 4637 Code: errorCode, 4638 Message: errorMessage, 4639 } 4640 return genericError 4641 4642 } 4643} 4644 4645func awsRestjson1_deserializeOpDocumentGetUsageStatisticsOutput(v **GetUsageStatisticsOutput, value interface{}) error { 4646 if v == nil { 4647 return fmt.Errorf("unexpected nil of type %T", v) 4648 } 4649 if value == nil { 4650 return nil 4651 } 4652 4653 shape, ok := value.(map[string]interface{}) 4654 if !ok { 4655 return fmt.Errorf("unexpected JSON type %v", value) 4656 } 4657 4658 var sv *GetUsageStatisticsOutput 4659 if *v == nil { 4660 sv = &GetUsageStatisticsOutput{} 4661 } else { 4662 sv = *v 4663 } 4664 4665 for key, value := range shape { 4666 switch key { 4667 case "nextToken": 4668 if value != nil { 4669 jtv, ok := value.(string) 4670 if !ok { 4671 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4672 } 4673 sv.NextToken = ptr.String(jtv) 4674 } 4675 4676 case "usageStatistics": 4677 if err := awsRestjson1_deserializeDocumentUsageStatistics(&sv.UsageStatistics, value); err != nil { 4678 return err 4679 } 4680 4681 default: 4682 _, _ = key, value 4683 4684 } 4685 } 4686 *v = sv 4687 return nil 4688} 4689 4690type awsRestjson1_deserializeOpInviteMembers struct { 4691} 4692 4693func (*awsRestjson1_deserializeOpInviteMembers) ID() string { 4694 return "OperationDeserializer" 4695} 4696 4697func (m *awsRestjson1_deserializeOpInviteMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4698 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4699) { 4700 out, metadata, err = next.HandleDeserialize(ctx, in) 4701 if err != nil { 4702 return out, metadata, err 4703 } 4704 4705 response, ok := out.RawResponse.(*smithyhttp.Response) 4706 if !ok { 4707 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4708 } 4709 4710 if response.StatusCode < 200 || response.StatusCode >= 300 { 4711 return out, metadata, awsRestjson1_deserializeOpErrorInviteMembers(response, &metadata) 4712 } 4713 output := &InviteMembersOutput{} 4714 out.Result = output 4715 4716 var buff [1024]byte 4717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4718 4719 body := io.TeeReader(response.Body, ringBuffer) 4720 4721 decoder := json.NewDecoder(body) 4722 decoder.UseNumber() 4723 var shape interface{} 4724 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4725 var snapshot bytes.Buffer 4726 io.Copy(&snapshot, ringBuffer) 4727 err = &smithy.DeserializationError{ 4728 Err: fmt.Errorf("failed to decode response body, %w", err), 4729 Snapshot: snapshot.Bytes(), 4730 } 4731 return out, metadata, err 4732 } 4733 4734 err = awsRestjson1_deserializeOpDocumentInviteMembersOutput(&output, shape) 4735 if err != nil { 4736 var snapshot bytes.Buffer 4737 io.Copy(&snapshot, ringBuffer) 4738 return out, metadata, &smithy.DeserializationError{ 4739 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4740 Snapshot: snapshot.Bytes(), 4741 } 4742 } 4743 4744 return out, metadata, err 4745} 4746 4747func awsRestjson1_deserializeOpErrorInviteMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4748 var errorBuffer bytes.Buffer 4749 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4750 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4751 } 4752 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4753 4754 errorCode := "UnknownError" 4755 errorMessage := errorCode 4756 4757 code := response.Header.Get("X-Amzn-ErrorType") 4758 if len(code) != 0 { 4759 errorCode = restjson.SanitizeErrorCode(code) 4760 } 4761 4762 var buff [1024]byte 4763 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4764 4765 body := io.TeeReader(errorBody, ringBuffer) 4766 decoder := json.NewDecoder(body) 4767 decoder.UseNumber() 4768 code, message, err := restjson.GetErrorInfo(decoder) 4769 if err != nil { 4770 var snapshot bytes.Buffer 4771 io.Copy(&snapshot, ringBuffer) 4772 err = &smithy.DeserializationError{ 4773 Err: fmt.Errorf("failed to decode response body, %w", err), 4774 Snapshot: snapshot.Bytes(), 4775 } 4776 return err 4777 } 4778 4779 errorBody.Seek(0, io.SeekStart) 4780 if len(code) != 0 { 4781 errorCode = restjson.SanitizeErrorCode(code) 4782 } 4783 if len(message) != 0 { 4784 errorMessage = message 4785 } 4786 4787 switch { 4788 case strings.EqualFold("BadRequestException", errorCode): 4789 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4790 4791 case strings.EqualFold("InternalServerErrorException", errorCode): 4792 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4793 4794 default: 4795 genericError := &smithy.GenericAPIError{ 4796 Code: errorCode, 4797 Message: errorMessage, 4798 } 4799 return genericError 4800 4801 } 4802} 4803 4804func awsRestjson1_deserializeOpDocumentInviteMembersOutput(v **InviteMembersOutput, value interface{}) error { 4805 if v == nil { 4806 return fmt.Errorf("unexpected nil of type %T", v) 4807 } 4808 if value == nil { 4809 return nil 4810 } 4811 4812 shape, ok := value.(map[string]interface{}) 4813 if !ok { 4814 return fmt.Errorf("unexpected JSON type %v", value) 4815 } 4816 4817 var sv *InviteMembersOutput 4818 if *v == nil { 4819 sv = &InviteMembersOutput{} 4820 } else { 4821 sv = *v 4822 } 4823 4824 for key, value := range shape { 4825 switch key { 4826 case "unprocessedAccounts": 4827 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 4828 return err 4829 } 4830 4831 default: 4832 _, _ = key, value 4833 4834 } 4835 } 4836 *v = sv 4837 return nil 4838} 4839 4840type awsRestjson1_deserializeOpListDetectors struct { 4841} 4842 4843func (*awsRestjson1_deserializeOpListDetectors) ID() string { 4844 return "OperationDeserializer" 4845} 4846 4847func (m *awsRestjson1_deserializeOpListDetectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4848 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4849) { 4850 out, metadata, err = next.HandleDeserialize(ctx, in) 4851 if err != nil { 4852 return out, metadata, err 4853 } 4854 4855 response, ok := out.RawResponse.(*smithyhttp.Response) 4856 if !ok { 4857 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4858 } 4859 4860 if response.StatusCode < 200 || response.StatusCode >= 300 { 4861 return out, metadata, awsRestjson1_deserializeOpErrorListDetectors(response, &metadata) 4862 } 4863 output := &ListDetectorsOutput{} 4864 out.Result = output 4865 4866 var buff [1024]byte 4867 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4868 4869 body := io.TeeReader(response.Body, ringBuffer) 4870 4871 decoder := json.NewDecoder(body) 4872 decoder.UseNumber() 4873 var shape interface{} 4874 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4875 var snapshot bytes.Buffer 4876 io.Copy(&snapshot, ringBuffer) 4877 err = &smithy.DeserializationError{ 4878 Err: fmt.Errorf("failed to decode response body, %w", err), 4879 Snapshot: snapshot.Bytes(), 4880 } 4881 return out, metadata, err 4882 } 4883 4884 err = awsRestjson1_deserializeOpDocumentListDetectorsOutput(&output, shape) 4885 if err != nil { 4886 var snapshot bytes.Buffer 4887 io.Copy(&snapshot, ringBuffer) 4888 return out, metadata, &smithy.DeserializationError{ 4889 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4890 Snapshot: snapshot.Bytes(), 4891 } 4892 } 4893 4894 return out, metadata, err 4895} 4896 4897func awsRestjson1_deserializeOpErrorListDetectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4898 var errorBuffer bytes.Buffer 4899 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4900 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4901 } 4902 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4903 4904 errorCode := "UnknownError" 4905 errorMessage := errorCode 4906 4907 code := response.Header.Get("X-Amzn-ErrorType") 4908 if len(code) != 0 { 4909 errorCode = restjson.SanitizeErrorCode(code) 4910 } 4911 4912 var buff [1024]byte 4913 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4914 4915 body := io.TeeReader(errorBody, ringBuffer) 4916 decoder := json.NewDecoder(body) 4917 decoder.UseNumber() 4918 code, message, err := restjson.GetErrorInfo(decoder) 4919 if err != nil { 4920 var snapshot bytes.Buffer 4921 io.Copy(&snapshot, ringBuffer) 4922 err = &smithy.DeserializationError{ 4923 Err: fmt.Errorf("failed to decode response body, %w", err), 4924 Snapshot: snapshot.Bytes(), 4925 } 4926 return err 4927 } 4928 4929 errorBody.Seek(0, io.SeekStart) 4930 if len(code) != 0 { 4931 errorCode = restjson.SanitizeErrorCode(code) 4932 } 4933 if len(message) != 0 { 4934 errorMessage = message 4935 } 4936 4937 switch { 4938 case strings.EqualFold("BadRequestException", errorCode): 4939 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 4940 4941 case strings.EqualFold("InternalServerErrorException", errorCode): 4942 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 4943 4944 default: 4945 genericError := &smithy.GenericAPIError{ 4946 Code: errorCode, 4947 Message: errorMessage, 4948 } 4949 return genericError 4950 4951 } 4952} 4953 4954func awsRestjson1_deserializeOpDocumentListDetectorsOutput(v **ListDetectorsOutput, value interface{}) error { 4955 if v == nil { 4956 return fmt.Errorf("unexpected nil of type %T", v) 4957 } 4958 if value == nil { 4959 return nil 4960 } 4961 4962 shape, ok := value.(map[string]interface{}) 4963 if !ok { 4964 return fmt.Errorf("unexpected JSON type %v", value) 4965 } 4966 4967 var sv *ListDetectorsOutput 4968 if *v == nil { 4969 sv = &ListDetectorsOutput{} 4970 } else { 4971 sv = *v 4972 } 4973 4974 for key, value := range shape { 4975 switch key { 4976 case "detectorIds": 4977 if err := awsRestjson1_deserializeDocumentDetectorIds(&sv.DetectorIds, value); err != nil { 4978 return err 4979 } 4980 4981 case "nextToken": 4982 if value != nil { 4983 jtv, ok := value.(string) 4984 if !ok { 4985 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4986 } 4987 sv.NextToken = ptr.String(jtv) 4988 } 4989 4990 default: 4991 _, _ = key, value 4992 4993 } 4994 } 4995 *v = sv 4996 return nil 4997} 4998 4999type awsRestjson1_deserializeOpListFilters struct { 5000} 5001 5002func (*awsRestjson1_deserializeOpListFilters) ID() string { 5003 return "OperationDeserializer" 5004} 5005 5006func (m *awsRestjson1_deserializeOpListFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5007 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5008) { 5009 out, metadata, err = next.HandleDeserialize(ctx, in) 5010 if err != nil { 5011 return out, metadata, err 5012 } 5013 5014 response, ok := out.RawResponse.(*smithyhttp.Response) 5015 if !ok { 5016 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5017 } 5018 5019 if response.StatusCode < 200 || response.StatusCode >= 300 { 5020 return out, metadata, awsRestjson1_deserializeOpErrorListFilters(response, &metadata) 5021 } 5022 output := &ListFiltersOutput{} 5023 out.Result = output 5024 5025 var buff [1024]byte 5026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5027 5028 body := io.TeeReader(response.Body, ringBuffer) 5029 5030 decoder := json.NewDecoder(body) 5031 decoder.UseNumber() 5032 var shape interface{} 5033 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5034 var snapshot bytes.Buffer 5035 io.Copy(&snapshot, ringBuffer) 5036 err = &smithy.DeserializationError{ 5037 Err: fmt.Errorf("failed to decode response body, %w", err), 5038 Snapshot: snapshot.Bytes(), 5039 } 5040 return out, metadata, err 5041 } 5042 5043 err = awsRestjson1_deserializeOpDocumentListFiltersOutput(&output, shape) 5044 if err != nil { 5045 var snapshot bytes.Buffer 5046 io.Copy(&snapshot, ringBuffer) 5047 return out, metadata, &smithy.DeserializationError{ 5048 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5049 Snapshot: snapshot.Bytes(), 5050 } 5051 } 5052 5053 return out, metadata, err 5054} 5055 5056func awsRestjson1_deserializeOpErrorListFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5057 var errorBuffer bytes.Buffer 5058 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5059 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5060 } 5061 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5062 5063 errorCode := "UnknownError" 5064 errorMessage := errorCode 5065 5066 code := response.Header.Get("X-Amzn-ErrorType") 5067 if len(code) != 0 { 5068 errorCode = restjson.SanitizeErrorCode(code) 5069 } 5070 5071 var buff [1024]byte 5072 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5073 5074 body := io.TeeReader(errorBody, ringBuffer) 5075 decoder := json.NewDecoder(body) 5076 decoder.UseNumber() 5077 code, message, err := restjson.GetErrorInfo(decoder) 5078 if err != nil { 5079 var snapshot bytes.Buffer 5080 io.Copy(&snapshot, ringBuffer) 5081 err = &smithy.DeserializationError{ 5082 Err: fmt.Errorf("failed to decode response body, %w", err), 5083 Snapshot: snapshot.Bytes(), 5084 } 5085 return err 5086 } 5087 5088 errorBody.Seek(0, io.SeekStart) 5089 if len(code) != 0 { 5090 errorCode = restjson.SanitizeErrorCode(code) 5091 } 5092 if len(message) != 0 { 5093 errorMessage = message 5094 } 5095 5096 switch { 5097 case strings.EqualFold("BadRequestException", errorCode): 5098 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5099 5100 case strings.EqualFold("InternalServerErrorException", errorCode): 5101 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5102 5103 default: 5104 genericError := &smithy.GenericAPIError{ 5105 Code: errorCode, 5106 Message: errorMessage, 5107 } 5108 return genericError 5109 5110 } 5111} 5112 5113func awsRestjson1_deserializeOpDocumentListFiltersOutput(v **ListFiltersOutput, value interface{}) error { 5114 if v == nil { 5115 return fmt.Errorf("unexpected nil of type %T", v) 5116 } 5117 if value == nil { 5118 return nil 5119 } 5120 5121 shape, ok := value.(map[string]interface{}) 5122 if !ok { 5123 return fmt.Errorf("unexpected JSON type %v", value) 5124 } 5125 5126 var sv *ListFiltersOutput 5127 if *v == nil { 5128 sv = &ListFiltersOutput{} 5129 } else { 5130 sv = *v 5131 } 5132 5133 for key, value := range shape { 5134 switch key { 5135 case "filterNames": 5136 if err := awsRestjson1_deserializeDocumentFilterNames(&sv.FilterNames, value); err != nil { 5137 return err 5138 } 5139 5140 case "nextToken": 5141 if value != nil { 5142 jtv, ok := value.(string) 5143 if !ok { 5144 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5145 } 5146 sv.NextToken = ptr.String(jtv) 5147 } 5148 5149 default: 5150 _, _ = key, value 5151 5152 } 5153 } 5154 *v = sv 5155 return nil 5156} 5157 5158type awsRestjson1_deserializeOpListFindings struct { 5159} 5160 5161func (*awsRestjson1_deserializeOpListFindings) ID() string { 5162 return "OperationDeserializer" 5163} 5164 5165func (m *awsRestjson1_deserializeOpListFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5166 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5167) { 5168 out, metadata, err = next.HandleDeserialize(ctx, in) 5169 if err != nil { 5170 return out, metadata, err 5171 } 5172 5173 response, ok := out.RawResponse.(*smithyhttp.Response) 5174 if !ok { 5175 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5176 } 5177 5178 if response.StatusCode < 200 || response.StatusCode >= 300 { 5179 return out, metadata, awsRestjson1_deserializeOpErrorListFindings(response, &metadata) 5180 } 5181 output := &ListFindingsOutput{} 5182 out.Result = output 5183 5184 var buff [1024]byte 5185 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5186 5187 body := io.TeeReader(response.Body, ringBuffer) 5188 5189 decoder := json.NewDecoder(body) 5190 decoder.UseNumber() 5191 var shape interface{} 5192 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5193 var snapshot bytes.Buffer 5194 io.Copy(&snapshot, ringBuffer) 5195 err = &smithy.DeserializationError{ 5196 Err: fmt.Errorf("failed to decode response body, %w", err), 5197 Snapshot: snapshot.Bytes(), 5198 } 5199 return out, metadata, err 5200 } 5201 5202 err = awsRestjson1_deserializeOpDocumentListFindingsOutput(&output, shape) 5203 if err != nil { 5204 var snapshot bytes.Buffer 5205 io.Copy(&snapshot, ringBuffer) 5206 return out, metadata, &smithy.DeserializationError{ 5207 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5208 Snapshot: snapshot.Bytes(), 5209 } 5210 } 5211 5212 return out, metadata, err 5213} 5214 5215func awsRestjson1_deserializeOpErrorListFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5216 var errorBuffer bytes.Buffer 5217 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5218 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5219 } 5220 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5221 5222 errorCode := "UnknownError" 5223 errorMessage := errorCode 5224 5225 code := response.Header.Get("X-Amzn-ErrorType") 5226 if len(code) != 0 { 5227 errorCode = restjson.SanitizeErrorCode(code) 5228 } 5229 5230 var buff [1024]byte 5231 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5232 5233 body := io.TeeReader(errorBody, ringBuffer) 5234 decoder := json.NewDecoder(body) 5235 decoder.UseNumber() 5236 code, message, err := restjson.GetErrorInfo(decoder) 5237 if err != nil { 5238 var snapshot bytes.Buffer 5239 io.Copy(&snapshot, ringBuffer) 5240 err = &smithy.DeserializationError{ 5241 Err: fmt.Errorf("failed to decode response body, %w", err), 5242 Snapshot: snapshot.Bytes(), 5243 } 5244 return err 5245 } 5246 5247 errorBody.Seek(0, io.SeekStart) 5248 if len(code) != 0 { 5249 errorCode = restjson.SanitizeErrorCode(code) 5250 } 5251 if len(message) != 0 { 5252 errorMessage = message 5253 } 5254 5255 switch { 5256 case strings.EqualFold("BadRequestException", errorCode): 5257 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5258 5259 case strings.EqualFold("InternalServerErrorException", errorCode): 5260 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5261 5262 default: 5263 genericError := &smithy.GenericAPIError{ 5264 Code: errorCode, 5265 Message: errorMessage, 5266 } 5267 return genericError 5268 5269 } 5270} 5271 5272func awsRestjson1_deserializeOpDocumentListFindingsOutput(v **ListFindingsOutput, value interface{}) error { 5273 if v == nil { 5274 return fmt.Errorf("unexpected nil of type %T", v) 5275 } 5276 if value == nil { 5277 return nil 5278 } 5279 5280 shape, ok := value.(map[string]interface{}) 5281 if !ok { 5282 return fmt.Errorf("unexpected JSON type %v", value) 5283 } 5284 5285 var sv *ListFindingsOutput 5286 if *v == nil { 5287 sv = &ListFindingsOutput{} 5288 } else { 5289 sv = *v 5290 } 5291 5292 for key, value := range shape { 5293 switch key { 5294 case "findingIds": 5295 if err := awsRestjson1_deserializeDocumentFindingIds(&sv.FindingIds, value); err != nil { 5296 return err 5297 } 5298 5299 case "nextToken": 5300 if value != nil { 5301 jtv, ok := value.(string) 5302 if !ok { 5303 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5304 } 5305 sv.NextToken = ptr.String(jtv) 5306 } 5307 5308 default: 5309 _, _ = key, value 5310 5311 } 5312 } 5313 *v = sv 5314 return nil 5315} 5316 5317type awsRestjson1_deserializeOpListInvitations struct { 5318} 5319 5320func (*awsRestjson1_deserializeOpListInvitations) ID() string { 5321 return "OperationDeserializer" 5322} 5323 5324func (m *awsRestjson1_deserializeOpListInvitations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5325 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5326) { 5327 out, metadata, err = next.HandleDeserialize(ctx, in) 5328 if err != nil { 5329 return out, metadata, err 5330 } 5331 5332 response, ok := out.RawResponse.(*smithyhttp.Response) 5333 if !ok { 5334 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5335 } 5336 5337 if response.StatusCode < 200 || response.StatusCode >= 300 { 5338 return out, metadata, awsRestjson1_deserializeOpErrorListInvitations(response, &metadata) 5339 } 5340 output := &ListInvitationsOutput{} 5341 out.Result = output 5342 5343 var buff [1024]byte 5344 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5345 5346 body := io.TeeReader(response.Body, ringBuffer) 5347 5348 decoder := json.NewDecoder(body) 5349 decoder.UseNumber() 5350 var shape interface{} 5351 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5352 var snapshot bytes.Buffer 5353 io.Copy(&snapshot, ringBuffer) 5354 err = &smithy.DeserializationError{ 5355 Err: fmt.Errorf("failed to decode response body, %w", err), 5356 Snapshot: snapshot.Bytes(), 5357 } 5358 return out, metadata, err 5359 } 5360 5361 err = awsRestjson1_deserializeOpDocumentListInvitationsOutput(&output, shape) 5362 if err != nil { 5363 var snapshot bytes.Buffer 5364 io.Copy(&snapshot, ringBuffer) 5365 return out, metadata, &smithy.DeserializationError{ 5366 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5367 Snapshot: snapshot.Bytes(), 5368 } 5369 } 5370 5371 return out, metadata, err 5372} 5373 5374func awsRestjson1_deserializeOpErrorListInvitations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5375 var errorBuffer bytes.Buffer 5376 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5377 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5378 } 5379 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5380 5381 errorCode := "UnknownError" 5382 errorMessage := errorCode 5383 5384 code := response.Header.Get("X-Amzn-ErrorType") 5385 if len(code) != 0 { 5386 errorCode = restjson.SanitizeErrorCode(code) 5387 } 5388 5389 var buff [1024]byte 5390 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5391 5392 body := io.TeeReader(errorBody, ringBuffer) 5393 decoder := json.NewDecoder(body) 5394 decoder.UseNumber() 5395 code, message, err := restjson.GetErrorInfo(decoder) 5396 if err != nil { 5397 var snapshot bytes.Buffer 5398 io.Copy(&snapshot, ringBuffer) 5399 err = &smithy.DeserializationError{ 5400 Err: fmt.Errorf("failed to decode response body, %w", err), 5401 Snapshot: snapshot.Bytes(), 5402 } 5403 return err 5404 } 5405 5406 errorBody.Seek(0, io.SeekStart) 5407 if len(code) != 0 { 5408 errorCode = restjson.SanitizeErrorCode(code) 5409 } 5410 if len(message) != 0 { 5411 errorMessage = message 5412 } 5413 5414 switch { 5415 case strings.EqualFold("BadRequestException", errorCode): 5416 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5417 5418 case strings.EqualFold("InternalServerErrorException", errorCode): 5419 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5420 5421 default: 5422 genericError := &smithy.GenericAPIError{ 5423 Code: errorCode, 5424 Message: errorMessage, 5425 } 5426 return genericError 5427 5428 } 5429} 5430 5431func awsRestjson1_deserializeOpDocumentListInvitationsOutput(v **ListInvitationsOutput, value interface{}) error { 5432 if v == nil { 5433 return fmt.Errorf("unexpected nil of type %T", v) 5434 } 5435 if value == nil { 5436 return nil 5437 } 5438 5439 shape, ok := value.(map[string]interface{}) 5440 if !ok { 5441 return fmt.Errorf("unexpected JSON type %v", value) 5442 } 5443 5444 var sv *ListInvitationsOutput 5445 if *v == nil { 5446 sv = &ListInvitationsOutput{} 5447 } else { 5448 sv = *v 5449 } 5450 5451 for key, value := range shape { 5452 switch key { 5453 case "invitations": 5454 if err := awsRestjson1_deserializeDocumentInvitations(&sv.Invitations, value); err != nil { 5455 return err 5456 } 5457 5458 case "nextToken": 5459 if value != nil { 5460 jtv, ok := value.(string) 5461 if !ok { 5462 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5463 } 5464 sv.NextToken = ptr.String(jtv) 5465 } 5466 5467 default: 5468 _, _ = key, value 5469 5470 } 5471 } 5472 *v = sv 5473 return nil 5474} 5475 5476type awsRestjson1_deserializeOpListIPSets struct { 5477} 5478 5479func (*awsRestjson1_deserializeOpListIPSets) ID() string { 5480 return "OperationDeserializer" 5481} 5482 5483func (m *awsRestjson1_deserializeOpListIPSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5484 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5485) { 5486 out, metadata, err = next.HandleDeserialize(ctx, in) 5487 if err != nil { 5488 return out, metadata, err 5489 } 5490 5491 response, ok := out.RawResponse.(*smithyhttp.Response) 5492 if !ok { 5493 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5494 } 5495 5496 if response.StatusCode < 200 || response.StatusCode >= 300 { 5497 return out, metadata, awsRestjson1_deserializeOpErrorListIPSets(response, &metadata) 5498 } 5499 output := &ListIPSetsOutput{} 5500 out.Result = output 5501 5502 var buff [1024]byte 5503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5504 5505 body := io.TeeReader(response.Body, ringBuffer) 5506 5507 decoder := json.NewDecoder(body) 5508 decoder.UseNumber() 5509 var shape interface{} 5510 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5511 var snapshot bytes.Buffer 5512 io.Copy(&snapshot, ringBuffer) 5513 err = &smithy.DeserializationError{ 5514 Err: fmt.Errorf("failed to decode response body, %w", err), 5515 Snapshot: snapshot.Bytes(), 5516 } 5517 return out, metadata, err 5518 } 5519 5520 err = awsRestjson1_deserializeOpDocumentListIPSetsOutput(&output, shape) 5521 if err != nil { 5522 var snapshot bytes.Buffer 5523 io.Copy(&snapshot, ringBuffer) 5524 return out, metadata, &smithy.DeserializationError{ 5525 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5526 Snapshot: snapshot.Bytes(), 5527 } 5528 } 5529 5530 return out, metadata, err 5531} 5532 5533func awsRestjson1_deserializeOpErrorListIPSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5534 var errorBuffer bytes.Buffer 5535 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5536 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5537 } 5538 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5539 5540 errorCode := "UnknownError" 5541 errorMessage := errorCode 5542 5543 code := response.Header.Get("X-Amzn-ErrorType") 5544 if len(code) != 0 { 5545 errorCode = restjson.SanitizeErrorCode(code) 5546 } 5547 5548 var buff [1024]byte 5549 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5550 5551 body := io.TeeReader(errorBody, ringBuffer) 5552 decoder := json.NewDecoder(body) 5553 decoder.UseNumber() 5554 code, message, err := restjson.GetErrorInfo(decoder) 5555 if err != nil { 5556 var snapshot bytes.Buffer 5557 io.Copy(&snapshot, ringBuffer) 5558 err = &smithy.DeserializationError{ 5559 Err: fmt.Errorf("failed to decode response body, %w", err), 5560 Snapshot: snapshot.Bytes(), 5561 } 5562 return err 5563 } 5564 5565 errorBody.Seek(0, io.SeekStart) 5566 if len(code) != 0 { 5567 errorCode = restjson.SanitizeErrorCode(code) 5568 } 5569 if len(message) != 0 { 5570 errorMessage = message 5571 } 5572 5573 switch { 5574 case strings.EqualFold("BadRequestException", errorCode): 5575 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5576 5577 case strings.EqualFold("InternalServerErrorException", errorCode): 5578 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5579 5580 default: 5581 genericError := &smithy.GenericAPIError{ 5582 Code: errorCode, 5583 Message: errorMessage, 5584 } 5585 return genericError 5586 5587 } 5588} 5589 5590func awsRestjson1_deserializeOpDocumentListIPSetsOutput(v **ListIPSetsOutput, value interface{}) error { 5591 if v == nil { 5592 return fmt.Errorf("unexpected nil of type %T", v) 5593 } 5594 if value == nil { 5595 return nil 5596 } 5597 5598 shape, ok := value.(map[string]interface{}) 5599 if !ok { 5600 return fmt.Errorf("unexpected JSON type %v", value) 5601 } 5602 5603 var sv *ListIPSetsOutput 5604 if *v == nil { 5605 sv = &ListIPSetsOutput{} 5606 } else { 5607 sv = *v 5608 } 5609 5610 for key, value := range shape { 5611 switch key { 5612 case "ipSetIds": 5613 if err := awsRestjson1_deserializeDocumentIpSetIds(&sv.IpSetIds, value); err != nil { 5614 return err 5615 } 5616 5617 case "nextToken": 5618 if value != nil { 5619 jtv, ok := value.(string) 5620 if !ok { 5621 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5622 } 5623 sv.NextToken = ptr.String(jtv) 5624 } 5625 5626 default: 5627 _, _ = key, value 5628 5629 } 5630 } 5631 *v = sv 5632 return nil 5633} 5634 5635type awsRestjson1_deserializeOpListMembers struct { 5636} 5637 5638func (*awsRestjson1_deserializeOpListMembers) ID() string { 5639 return "OperationDeserializer" 5640} 5641 5642func (m *awsRestjson1_deserializeOpListMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5643 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5644) { 5645 out, metadata, err = next.HandleDeserialize(ctx, in) 5646 if err != nil { 5647 return out, metadata, err 5648 } 5649 5650 response, ok := out.RawResponse.(*smithyhttp.Response) 5651 if !ok { 5652 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5653 } 5654 5655 if response.StatusCode < 200 || response.StatusCode >= 300 { 5656 return out, metadata, awsRestjson1_deserializeOpErrorListMembers(response, &metadata) 5657 } 5658 output := &ListMembersOutput{} 5659 out.Result = output 5660 5661 var buff [1024]byte 5662 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5663 5664 body := io.TeeReader(response.Body, ringBuffer) 5665 5666 decoder := json.NewDecoder(body) 5667 decoder.UseNumber() 5668 var shape interface{} 5669 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5670 var snapshot bytes.Buffer 5671 io.Copy(&snapshot, ringBuffer) 5672 err = &smithy.DeserializationError{ 5673 Err: fmt.Errorf("failed to decode response body, %w", err), 5674 Snapshot: snapshot.Bytes(), 5675 } 5676 return out, metadata, err 5677 } 5678 5679 err = awsRestjson1_deserializeOpDocumentListMembersOutput(&output, shape) 5680 if err != nil { 5681 var snapshot bytes.Buffer 5682 io.Copy(&snapshot, ringBuffer) 5683 return out, metadata, &smithy.DeserializationError{ 5684 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5685 Snapshot: snapshot.Bytes(), 5686 } 5687 } 5688 5689 return out, metadata, err 5690} 5691 5692func awsRestjson1_deserializeOpErrorListMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5693 var errorBuffer bytes.Buffer 5694 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5695 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5696 } 5697 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5698 5699 errorCode := "UnknownError" 5700 errorMessage := errorCode 5701 5702 code := response.Header.Get("X-Amzn-ErrorType") 5703 if len(code) != 0 { 5704 errorCode = restjson.SanitizeErrorCode(code) 5705 } 5706 5707 var buff [1024]byte 5708 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5709 5710 body := io.TeeReader(errorBody, ringBuffer) 5711 decoder := json.NewDecoder(body) 5712 decoder.UseNumber() 5713 code, message, err := restjson.GetErrorInfo(decoder) 5714 if err != nil { 5715 var snapshot bytes.Buffer 5716 io.Copy(&snapshot, ringBuffer) 5717 err = &smithy.DeserializationError{ 5718 Err: fmt.Errorf("failed to decode response body, %w", err), 5719 Snapshot: snapshot.Bytes(), 5720 } 5721 return err 5722 } 5723 5724 errorBody.Seek(0, io.SeekStart) 5725 if len(code) != 0 { 5726 errorCode = restjson.SanitizeErrorCode(code) 5727 } 5728 if len(message) != 0 { 5729 errorMessage = message 5730 } 5731 5732 switch { 5733 case strings.EqualFold("BadRequestException", errorCode): 5734 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5735 5736 case strings.EqualFold("InternalServerErrorException", errorCode): 5737 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5738 5739 default: 5740 genericError := &smithy.GenericAPIError{ 5741 Code: errorCode, 5742 Message: errorMessage, 5743 } 5744 return genericError 5745 5746 } 5747} 5748 5749func awsRestjson1_deserializeOpDocumentListMembersOutput(v **ListMembersOutput, value interface{}) error { 5750 if v == nil { 5751 return fmt.Errorf("unexpected nil of type %T", v) 5752 } 5753 if value == nil { 5754 return nil 5755 } 5756 5757 shape, ok := value.(map[string]interface{}) 5758 if !ok { 5759 return fmt.Errorf("unexpected JSON type %v", value) 5760 } 5761 5762 var sv *ListMembersOutput 5763 if *v == nil { 5764 sv = &ListMembersOutput{} 5765 } else { 5766 sv = *v 5767 } 5768 5769 for key, value := range shape { 5770 switch key { 5771 case "members": 5772 if err := awsRestjson1_deserializeDocumentMembers(&sv.Members, value); err != nil { 5773 return err 5774 } 5775 5776 case "nextToken": 5777 if value != nil { 5778 jtv, ok := value.(string) 5779 if !ok { 5780 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5781 } 5782 sv.NextToken = ptr.String(jtv) 5783 } 5784 5785 default: 5786 _, _ = key, value 5787 5788 } 5789 } 5790 *v = sv 5791 return nil 5792} 5793 5794type awsRestjson1_deserializeOpListOrganizationAdminAccounts struct { 5795} 5796 5797func (*awsRestjson1_deserializeOpListOrganizationAdminAccounts) ID() string { 5798 return "OperationDeserializer" 5799} 5800 5801func (m *awsRestjson1_deserializeOpListOrganizationAdminAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5802 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5803) { 5804 out, metadata, err = next.HandleDeserialize(ctx, in) 5805 if err != nil { 5806 return out, metadata, err 5807 } 5808 5809 response, ok := out.RawResponse.(*smithyhttp.Response) 5810 if !ok { 5811 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5812 } 5813 5814 if response.StatusCode < 200 || response.StatusCode >= 300 { 5815 return out, metadata, awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response, &metadata) 5816 } 5817 output := &ListOrganizationAdminAccountsOutput{} 5818 out.Result = output 5819 5820 var buff [1024]byte 5821 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5822 5823 body := io.TeeReader(response.Body, ringBuffer) 5824 5825 decoder := json.NewDecoder(body) 5826 decoder.UseNumber() 5827 var shape interface{} 5828 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5829 var snapshot bytes.Buffer 5830 io.Copy(&snapshot, ringBuffer) 5831 err = &smithy.DeserializationError{ 5832 Err: fmt.Errorf("failed to decode response body, %w", err), 5833 Snapshot: snapshot.Bytes(), 5834 } 5835 return out, metadata, err 5836 } 5837 5838 err = awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(&output, shape) 5839 if err != nil { 5840 var snapshot bytes.Buffer 5841 io.Copy(&snapshot, ringBuffer) 5842 return out, metadata, &smithy.DeserializationError{ 5843 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5844 Snapshot: snapshot.Bytes(), 5845 } 5846 } 5847 5848 return out, metadata, err 5849} 5850 5851func awsRestjson1_deserializeOpErrorListOrganizationAdminAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5852 var errorBuffer bytes.Buffer 5853 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5854 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5855 } 5856 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5857 5858 errorCode := "UnknownError" 5859 errorMessage := errorCode 5860 5861 code := response.Header.Get("X-Amzn-ErrorType") 5862 if len(code) != 0 { 5863 errorCode = restjson.SanitizeErrorCode(code) 5864 } 5865 5866 var buff [1024]byte 5867 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5868 5869 body := io.TeeReader(errorBody, ringBuffer) 5870 decoder := json.NewDecoder(body) 5871 decoder.UseNumber() 5872 code, message, err := restjson.GetErrorInfo(decoder) 5873 if err != nil { 5874 var snapshot bytes.Buffer 5875 io.Copy(&snapshot, ringBuffer) 5876 err = &smithy.DeserializationError{ 5877 Err: fmt.Errorf("failed to decode response body, %w", err), 5878 Snapshot: snapshot.Bytes(), 5879 } 5880 return err 5881 } 5882 5883 errorBody.Seek(0, io.SeekStart) 5884 if len(code) != 0 { 5885 errorCode = restjson.SanitizeErrorCode(code) 5886 } 5887 if len(message) != 0 { 5888 errorMessage = message 5889 } 5890 5891 switch { 5892 case strings.EqualFold("BadRequestException", errorCode): 5893 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 5894 5895 case strings.EqualFold("InternalServerErrorException", errorCode): 5896 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 5897 5898 default: 5899 genericError := &smithy.GenericAPIError{ 5900 Code: errorCode, 5901 Message: errorMessage, 5902 } 5903 return genericError 5904 5905 } 5906} 5907 5908func awsRestjson1_deserializeOpDocumentListOrganizationAdminAccountsOutput(v **ListOrganizationAdminAccountsOutput, value interface{}) error { 5909 if v == nil { 5910 return fmt.Errorf("unexpected nil of type %T", v) 5911 } 5912 if value == nil { 5913 return nil 5914 } 5915 5916 shape, ok := value.(map[string]interface{}) 5917 if !ok { 5918 return fmt.Errorf("unexpected JSON type %v", value) 5919 } 5920 5921 var sv *ListOrganizationAdminAccountsOutput 5922 if *v == nil { 5923 sv = &ListOrganizationAdminAccountsOutput{} 5924 } else { 5925 sv = *v 5926 } 5927 5928 for key, value := range shape { 5929 switch key { 5930 case "adminAccounts": 5931 if err := awsRestjson1_deserializeDocumentAdminAccounts(&sv.AdminAccounts, value); err != nil { 5932 return err 5933 } 5934 5935 case "nextToken": 5936 if value != nil { 5937 jtv, ok := value.(string) 5938 if !ok { 5939 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5940 } 5941 sv.NextToken = ptr.String(jtv) 5942 } 5943 5944 default: 5945 _, _ = key, value 5946 5947 } 5948 } 5949 *v = sv 5950 return nil 5951} 5952 5953type awsRestjson1_deserializeOpListPublishingDestinations struct { 5954} 5955 5956func (*awsRestjson1_deserializeOpListPublishingDestinations) ID() string { 5957 return "OperationDeserializer" 5958} 5959 5960func (m *awsRestjson1_deserializeOpListPublishingDestinations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5962) { 5963 out, metadata, err = next.HandleDeserialize(ctx, in) 5964 if err != nil { 5965 return out, metadata, err 5966 } 5967 5968 response, ok := out.RawResponse.(*smithyhttp.Response) 5969 if !ok { 5970 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5971 } 5972 5973 if response.StatusCode < 200 || response.StatusCode >= 300 { 5974 return out, metadata, awsRestjson1_deserializeOpErrorListPublishingDestinations(response, &metadata) 5975 } 5976 output := &ListPublishingDestinationsOutput{} 5977 out.Result = output 5978 5979 var buff [1024]byte 5980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5981 5982 body := io.TeeReader(response.Body, ringBuffer) 5983 5984 decoder := json.NewDecoder(body) 5985 decoder.UseNumber() 5986 var shape interface{} 5987 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5988 var snapshot bytes.Buffer 5989 io.Copy(&snapshot, ringBuffer) 5990 err = &smithy.DeserializationError{ 5991 Err: fmt.Errorf("failed to decode response body, %w", err), 5992 Snapshot: snapshot.Bytes(), 5993 } 5994 return out, metadata, err 5995 } 5996 5997 err = awsRestjson1_deserializeOpDocumentListPublishingDestinationsOutput(&output, shape) 5998 if err != nil { 5999 var snapshot bytes.Buffer 6000 io.Copy(&snapshot, ringBuffer) 6001 return out, metadata, &smithy.DeserializationError{ 6002 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6003 Snapshot: snapshot.Bytes(), 6004 } 6005 } 6006 6007 return out, metadata, err 6008} 6009 6010func awsRestjson1_deserializeOpErrorListPublishingDestinations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6011 var errorBuffer bytes.Buffer 6012 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6013 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6014 } 6015 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6016 6017 errorCode := "UnknownError" 6018 errorMessage := errorCode 6019 6020 code := response.Header.Get("X-Amzn-ErrorType") 6021 if len(code) != 0 { 6022 errorCode = restjson.SanitizeErrorCode(code) 6023 } 6024 6025 var buff [1024]byte 6026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6027 6028 body := io.TeeReader(errorBody, ringBuffer) 6029 decoder := json.NewDecoder(body) 6030 decoder.UseNumber() 6031 code, message, err := restjson.GetErrorInfo(decoder) 6032 if err != nil { 6033 var snapshot bytes.Buffer 6034 io.Copy(&snapshot, ringBuffer) 6035 err = &smithy.DeserializationError{ 6036 Err: fmt.Errorf("failed to decode response body, %w", err), 6037 Snapshot: snapshot.Bytes(), 6038 } 6039 return err 6040 } 6041 6042 errorBody.Seek(0, io.SeekStart) 6043 if len(code) != 0 { 6044 errorCode = restjson.SanitizeErrorCode(code) 6045 } 6046 if len(message) != 0 { 6047 errorMessage = message 6048 } 6049 6050 switch { 6051 case strings.EqualFold("BadRequestException", errorCode): 6052 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6053 6054 case strings.EqualFold("InternalServerErrorException", errorCode): 6055 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6056 6057 default: 6058 genericError := &smithy.GenericAPIError{ 6059 Code: errorCode, 6060 Message: errorMessage, 6061 } 6062 return genericError 6063 6064 } 6065} 6066 6067func awsRestjson1_deserializeOpDocumentListPublishingDestinationsOutput(v **ListPublishingDestinationsOutput, value interface{}) error { 6068 if v == nil { 6069 return fmt.Errorf("unexpected nil of type %T", v) 6070 } 6071 if value == nil { 6072 return nil 6073 } 6074 6075 shape, ok := value.(map[string]interface{}) 6076 if !ok { 6077 return fmt.Errorf("unexpected JSON type %v", value) 6078 } 6079 6080 var sv *ListPublishingDestinationsOutput 6081 if *v == nil { 6082 sv = &ListPublishingDestinationsOutput{} 6083 } else { 6084 sv = *v 6085 } 6086 6087 for key, value := range shape { 6088 switch key { 6089 case "destinations": 6090 if err := awsRestjson1_deserializeDocumentDestinations(&sv.Destinations, value); err != nil { 6091 return err 6092 } 6093 6094 case "nextToken": 6095 if value != nil { 6096 jtv, ok := value.(string) 6097 if !ok { 6098 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6099 } 6100 sv.NextToken = ptr.String(jtv) 6101 } 6102 6103 default: 6104 _, _ = key, value 6105 6106 } 6107 } 6108 *v = sv 6109 return nil 6110} 6111 6112type awsRestjson1_deserializeOpListTagsForResource struct { 6113} 6114 6115func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 6116 return "OperationDeserializer" 6117} 6118 6119func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6120 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6121) { 6122 out, metadata, err = next.HandleDeserialize(ctx, in) 6123 if err != nil { 6124 return out, metadata, err 6125 } 6126 6127 response, ok := out.RawResponse.(*smithyhttp.Response) 6128 if !ok { 6129 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6130 } 6131 6132 if response.StatusCode < 200 || response.StatusCode >= 300 { 6133 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 6134 } 6135 output := &ListTagsForResourceOutput{} 6136 out.Result = output 6137 6138 var buff [1024]byte 6139 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6140 6141 body := io.TeeReader(response.Body, ringBuffer) 6142 6143 decoder := json.NewDecoder(body) 6144 decoder.UseNumber() 6145 var shape interface{} 6146 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6147 var snapshot bytes.Buffer 6148 io.Copy(&snapshot, ringBuffer) 6149 err = &smithy.DeserializationError{ 6150 Err: fmt.Errorf("failed to decode response body, %w", err), 6151 Snapshot: snapshot.Bytes(), 6152 } 6153 return out, metadata, err 6154 } 6155 6156 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 6157 if err != nil { 6158 var snapshot bytes.Buffer 6159 io.Copy(&snapshot, ringBuffer) 6160 return out, metadata, &smithy.DeserializationError{ 6161 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6162 Snapshot: snapshot.Bytes(), 6163 } 6164 } 6165 6166 return out, metadata, err 6167} 6168 6169func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6170 var errorBuffer bytes.Buffer 6171 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6172 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6173 } 6174 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6175 6176 errorCode := "UnknownError" 6177 errorMessage := errorCode 6178 6179 code := response.Header.Get("X-Amzn-ErrorType") 6180 if len(code) != 0 { 6181 errorCode = restjson.SanitizeErrorCode(code) 6182 } 6183 6184 var buff [1024]byte 6185 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6186 6187 body := io.TeeReader(errorBody, ringBuffer) 6188 decoder := json.NewDecoder(body) 6189 decoder.UseNumber() 6190 code, message, err := restjson.GetErrorInfo(decoder) 6191 if err != nil { 6192 var snapshot bytes.Buffer 6193 io.Copy(&snapshot, ringBuffer) 6194 err = &smithy.DeserializationError{ 6195 Err: fmt.Errorf("failed to decode response body, %w", err), 6196 Snapshot: snapshot.Bytes(), 6197 } 6198 return err 6199 } 6200 6201 errorBody.Seek(0, io.SeekStart) 6202 if len(code) != 0 { 6203 errorCode = restjson.SanitizeErrorCode(code) 6204 } 6205 if len(message) != 0 { 6206 errorMessage = message 6207 } 6208 6209 switch { 6210 case strings.EqualFold("BadRequestException", errorCode): 6211 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6212 6213 case strings.EqualFold("InternalServerErrorException", errorCode): 6214 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6215 6216 default: 6217 genericError := &smithy.GenericAPIError{ 6218 Code: errorCode, 6219 Message: errorMessage, 6220 } 6221 return genericError 6222 6223 } 6224} 6225 6226func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 6227 if v == nil { 6228 return fmt.Errorf("unexpected nil of type %T", v) 6229 } 6230 if value == nil { 6231 return nil 6232 } 6233 6234 shape, ok := value.(map[string]interface{}) 6235 if !ok { 6236 return fmt.Errorf("unexpected JSON type %v", value) 6237 } 6238 6239 var sv *ListTagsForResourceOutput 6240 if *v == nil { 6241 sv = &ListTagsForResourceOutput{} 6242 } else { 6243 sv = *v 6244 } 6245 6246 for key, value := range shape { 6247 switch key { 6248 case "tags": 6249 if err := awsRestjson1_deserializeDocumentTagMap(&sv.Tags, value); err != nil { 6250 return err 6251 } 6252 6253 default: 6254 _, _ = key, value 6255 6256 } 6257 } 6258 *v = sv 6259 return nil 6260} 6261 6262type awsRestjson1_deserializeOpListThreatIntelSets struct { 6263} 6264 6265func (*awsRestjson1_deserializeOpListThreatIntelSets) ID() string { 6266 return "OperationDeserializer" 6267} 6268 6269func (m *awsRestjson1_deserializeOpListThreatIntelSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6270 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6271) { 6272 out, metadata, err = next.HandleDeserialize(ctx, in) 6273 if err != nil { 6274 return out, metadata, err 6275 } 6276 6277 response, ok := out.RawResponse.(*smithyhttp.Response) 6278 if !ok { 6279 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6280 } 6281 6282 if response.StatusCode < 200 || response.StatusCode >= 300 { 6283 return out, metadata, awsRestjson1_deserializeOpErrorListThreatIntelSets(response, &metadata) 6284 } 6285 output := &ListThreatIntelSetsOutput{} 6286 out.Result = output 6287 6288 var buff [1024]byte 6289 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6290 6291 body := io.TeeReader(response.Body, ringBuffer) 6292 6293 decoder := json.NewDecoder(body) 6294 decoder.UseNumber() 6295 var shape interface{} 6296 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6297 var snapshot bytes.Buffer 6298 io.Copy(&snapshot, ringBuffer) 6299 err = &smithy.DeserializationError{ 6300 Err: fmt.Errorf("failed to decode response body, %w", err), 6301 Snapshot: snapshot.Bytes(), 6302 } 6303 return out, metadata, err 6304 } 6305 6306 err = awsRestjson1_deserializeOpDocumentListThreatIntelSetsOutput(&output, shape) 6307 if err != nil { 6308 var snapshot bytes.Buffer 6309 io.Copy(&snapshot, ringBuffer) 6310 return out, metadata, &smithy.DeserializationError{ 6311 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6312 Snapshot: snapshot.Bytes(), 6313 } 6314 } 6315 6316 return out, metadata, err 6317} 6318 6319func awsRestjson1_deserializeOpErrorListThreatIntelSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6320 var errorBuffer bytes.Buffer 6321 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6322 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6323 } 6324 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6325 6326 errorCode := "UnknownError" 6327 errorMessage := errorCode 6328 6329 code := response.Header.Get("X-Amzn-ErrorType") 6330 if len(code) != 0 { 6331 errorCode = restjson.SanitizeErrorCode(code) 6332 } 6333 6334 var buff [1024]byte 6335 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6336 6337 body := io.TeeReader(errorBody, ringBuffer) 6338 decoder := json.NewDecoder(body) 6339 decoder.UseNumber() 6340 code, message, err := restjson.GetErrorInfo(decoder) 6341 if err != nil { 6342 var snapshot bytes.Buffer 6343 io.Copy(&snapshot, ringBuffer) 6344 err = &smithy.DeserializationError{ 6345 Err: fmt.Errorf("failed to decode response body, %w", err), 6346 Snapshot: snapshot.Bytes(), 6347 } 6348 return err 6349 } 6350 6351 errorBody.Seek(0, io.SeekStart) 6352 if len(code) != 0 { 6353 errorCode = restjson.SanitizeErrorCode(code) 6354 } 6355 if len(message) != 0 { 6356 errorMessage = message 6357 } 6358 6359 switch { 6360 case strings.EqualFold("BadRequestException", errorCode): 6361 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6362 6363 case strings.EqualFold("InternalServerErrorException", errorCode): 6364 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6365 6366 default: 6367 genericError := &smithy.GenericAPIError{ 6368 Code: errorCode, 6369 Message: errorMessage, 6370 } 6371 return genericError 6372 6373 } 6374} 6375 6376func awsRestjson1_deserializeOpDocumentListThreatIntelSetsOutput(v **ListThreatIntelSetsOutput, value interface{}) error { 6377 if v == nil { 6378 return fmt.Errorf("unexpected nil of type %T", v) 6379 } 6380 if value == nil { 6381 return nil 6382 } 6383 6384 shape, ok := value.(map[string]interface{}) 6385 if !ok { 6386 return fmt.Errorf("unexpected JSON type %v", value) 6387 } 6388 6389 var sv *ListThreatIntelSetsOutput 6390 if *v == nil { 6391 sv = &ListThreatIntelSetsOutput{} 6392 } else { 6393 sv = *v 6394 } 6395 6396 for key, value := range shape { 6397 switch key { 6398 case "nextToken": 6399 if value != nil { 6400 jtv, ok := value.(string) 6401 if !ok { 6402 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6403 } 6404 sv.NextToken = ptr.String(jtv) 6405 } 6406 6407 case "threatIntelSetIds": 6408 if err := awsRestjson1_deserializeDocumentThreatIntelSetIds(&sv.ThreatIntelSetIds, value); err != nil { 6409 return err 6410 } 6411 6412 default: 6413 _, _ = key, value 6414 6415 } 6416 } 6417 *v = sv 6418 return nil 6419} 6420 6421type awsRestjson1_deserializeOpStartMonitoringMembers struct { 6422} 6423 6424func (*awsRestjson1_deserializeOpStartMonitoringMembers) ID() string { 6425 return "OperationDeserializer" 6426} 6427 6428func (m *awsRestjson1_deserializeOpStartMonitoringMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6429 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6430) { 6431 out, metadata, err = next.HandleDeserialize(ctx, in) 6432 if err != nil { 6433 return out, metadata, err 6434 } 6435 6436 response, ok := out.RawResponse.(*smithyhttp.Response) 6437 if !ok { 6438 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6439 } 6440 6441 if response.StatusCode < 200 || response.StatusCode >= 300 { 6442 return out, metadata, awsRestjson1_deserializeOpErrorStartMonitoringMembers(response, &metadata) 6443 } 6444 output := &StartMonitoringMembersOutput{} 6445 out.Result = output 6446 6447 var buff [1024]byte 6448 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6449 6450 body := io.TeeReader(response.Body, ringBuffer) 6451 6452 decoder := json.NewDecoder(body) 6453 decoder.UseNumber() 6454 var shape interface{} 6455 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6456 var snapshot bytes.Buffer 6457 io.Copy(&snapshot, ringBuffer) 6458 err = &smithy.DeserializationError{ 6459 Err: fmt.Errorf("failed to decode response body, %w", err), 6460 Snapshot: snapshot.Bytes(), 6461 } 6462 return out, metadata, err 6463 } 6464 6465 err = awsRestjson1_deserializeOpDocumentStartMonitoringMembersOutput(&output, shape) 6466 if err != nil { 6467 var snapshot bytes.Buffer 6468 io.Copy(&snapshot, ringBuffer) 6469 return out, metadata, &smithy.DeserializationError{ 6470 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6471 Snapshot: snapshot.Bytes(), 6472 } 6473 } 6474 6475 return out, metadata, err 6476} 6477 6478func awsRestjson1_deserializeOpErrorStartMonitoringMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6479 var errorBuffer bytes.Buffer 6480 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6481 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6482 } 6483 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6484 6485 errorCode := "UnknownError" 6486 errorMessage := errorCode 6487 6488 code := response.Header.Get("X-Amzn-ErrorType") 6489 if len(code) != 0 { 6490 errorCode = restjson.SanitizeErrorCode(code) 6491 } 6492 6493 var buff [1024]byte 6494 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6495 6496 body := io.TeeReader(errorBody, ringBuffer) 6497 decoder := json.NewDecoder(body) 6498 decoder.UseNumber() 6499 code, message, err := restjson.GetErrorInfo(decoder) 6500 if err != nil { 6501 var snapshot bytes.Buffer 6502 io.Copy(&snapshot, ringBuffer) 6503 err = &smithy.DeserializationError{ 6504 Err: fmt.Errorf("failed to decode response body, %w", err), 6505 Snapshot: snapshot.Bytes(), 6506 } 6507 return err 6508 } 6509 6510 errorBody.Seek(0, io.SeekStart) 6511 if len(code) != 0 { 6512 errorCode = restjson.SanitizeErrorCode(code) 6513 } 6514 if len(message) != 0 { 6515 errorMessage = message 6516 } 6517 6518 switch { 6519 case strings.EqualFold("BadRequestException", errorCode): 6520 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6521 6522 case strings.EqualFold("InternalServerErrorException", errorCode): 6523 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6524 6525 default: 6526 genericError := &smithy.GenericAPIError{ 6527 Code: errorCode, 6528 Message: errorMessage, 6529 } 6530 return genericError 6531 6532 } 6533} 6534 6535func awsRestjson1_deserializeOpDocumentStartMonitoringMembersOutput(v **StartMonitoringMembersOutput, value interface{}) error { 6536 if v == nil { 6537 return fmt.Errorf("unexpected nil of type %T", v) 6538 } 6539 if value == nil { 6540 return nil 6541 } 6542 6543 shape, ok := value.(map[string]interface{}) 6544 if !ok { 6545 return fmt.Errorf("unexpected JSON type %v", value) 6546 } 6547 6548 var sv *StartMonitoringMembersOutput 6549 if *v == nil { 6550 sv = &StartMonitoringMembersOutput{} 6551 } else { 6552 sv = *v 6553 } 6554 6555 for key, value := range shape { 6556 switch key { 6557 case "unprocessedAccounts": 6558 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 6559 return err 6560 } 6561 6562 default: 6563 _, _ = key, value 6564 6565 } 6566 } 6567 *v = sv 6568 return nil 6569} 6570 6571type awsRestjson1_deserializeOpStopMonitoringMembers struct { 6572} 6573 6574func (*awsRestjson1_deserializeOpStopMonitoringMembers) ID() string { 6575 return "OperationDeserializer" 6576} 6577 6578func (m *awsRestjson1_deserializeOpStopMonitoringMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6579 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6580) { 6581 out, metadata, err = next.HandleDeserialize(ctx, in) 6582 if err != nil { 6583 return out, metadata, err 6584 } 6585 6586 response, ok := out.RawResponse.(*smithyhttp.Response) 6587 if !ok { 6588 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6589 } 6590 6591 if response.StatusCode < 200 || response.StatusCode >= 300 { 6592 return out, metadata, awsRestjson1_deserializeOpErrorStopMonitoringMembers(response, &metadata) 6593 } 6594 output := &StopMonitoringMembersOutput{} 6595 out.Result = output 6596 6597 var buff [1024]byte 6598 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6599 6600 body := io.TeeReader(response.Body, ringBuffer) 6601 6602 decoder := json.NewDecoder(body) 6603 decoder.UseNumber() 6604 var shape interface{} 6605 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6606 var snapshot bytes.Buffer 6607 io.Copy(&snapshot, ringBuffer) 6608 err = &smithy.DeserializationError{ 6609 Err: fmt.Errorf("failed to decode response body, %w", err), 6610 Snapshot: snapshot.Bytes(), 6611 } 6612 return out, metadata, err 6613 } 6614 6615 err = awsRestjson1_deserializeOpDocumentStopMonitoringMembersOutput(&output, shape) 6616 if err != nil { 6617 var snapshot bytes.Buffer 6618 io.Copy(&snapshot, ringBuffer) 6619 return out, metadata, &smithy.DeserializationError{ 6620 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6621 Snapshot: snapshot.Bytes(), 6622 } 6623 } 6624 6625 return out, metadata, err 6626} 6627 6628func awsRestjson1_deserializeOpErrorStopMonitoringMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6629 var errorBuffer bytes.Buffer 6630 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6631 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6632 } 6633 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6634 6635 errorCode := "UnknownError" 6636 errorMessage := errorCode 6637 6638 code := response.Header.Get("X-Amzn-ErrorType") 6639 if len(code) != 0 { 6640 errorCode = restjson.SanitizeErrorCode(code) 6641 } 6642 6643 var buff [1024]byte 6644 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6645 6646 body := io.TeeReader(errorBody, ringBuffer) 6647 decoder := json.NewDecoder(body) 6648 decoder.UseNumber() 6649 code, message, err := restjson.GetErrorInfo(decoder) 6650 if err != nil { 6651 var snapshot bytes.Buffer 6652 io.Copy(&snapshot, ringBuffer) 6653 err = &smithy.DeserializationError{ 6654 Err: fmt.Errorf("failed to decode response body, %w", err), 6655 Snapshot: snapshot.Bytes(), 6656 } 6657 return err 6658 } 6659 6660 errorBody.Seek(0, io.SeekStart) 6661 if len(code) != 0 { 6662 errorCode = restjson.SanitizeErrorCode(code) 6663 } 6664 if len(message) != 0 { 6665 errorMessage = message 6666 } 6667 6668 switch { 6669 case strings.EqualFold("BadRequestException", errorCode): 6670 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6671 6672 case strings.EqualFold("InternalServerErrorException", errorCode): 6673 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6674 6675 default: 6676 genericError := &smithy.GenericAPIError{ 6677 Code: errorCode, 6678 Message: errorMessage, 6679 } 6680 return genericError 6681 6682 } 6683} 6684 6685func awsRestjson1_deserializeOpDocumentStopMonitoringMembersOutput(v **StopMonitoringMembersOutput, value interface{}) error { 6686 if v == nil { 6687 return fmt.Errorf("unexpected nil of type %T", v) 6688 } 6689 if value == nil { 6690 return nil 6691 } 6692 6693 shape, ok := value.(map[string]interface{}) 6694 if !ok { 6695 return fmt.Errorf("unexpected JSON type %v", value) 6696 } 6697 6698 var sv *StopMonitoringMembersOutput 6699 if *v == nil { 6700 sv = &StopMonitoringMembersOutput{} 6701 } else { 6702 sv = *v 6703 } 6704 6705 for key, value := range shape { 6706 switch key { 6707 case "unprocessedAccounts": 6708 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 6709 return err 6710 } 6711 6712 default: 6713 _, _ = key, value 6714 6715 } 6716 } 6717 *v = sv 6718 return nil 6719} 6720 6721type awsRestjson1_deserializeOpTagResource struct { 6722} 6723 6724func (*awsRestjson1_deserializeOpTagResource) ID() string { 6725 return "OperationDeserializer" 6726} 6727 6728func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6729 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6730) { 6731 out, metadata, err = next.HandleDeserialize(ctx, in) 6732 if err != nil { 6733 return out, metadata, err 6734 } 6735 6736 response, ok := out.RawResponse.(*smithyhttp.Response) 6737 if !ok { 6738 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6739 } 6740 6741 if response.StatusCode < 200 || response.StatusCode >= 300 { 6742 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 6743 } 6744 output := &TagResourceOutput{} 6745 out.Result = output 6746 6747 return out, metadata, err 6748} 6749 6750func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6751 var errorBuffer bytes.Buffer 6752 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6753 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6754 } 6755 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6756 6757 errorCode := "UnknownError" 6758 errorMessage := errorCode 6759 6760 code := response.Header.Get("X-Amzn-ErrorType") 6761 if len(code) != 0 { 6762 errorCode = restjson.SanitizeErrorCode(code) 6763 } 6764 6765 var buff [1024]byte 6766 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6767 6768 body := io.TeeReader(errorBody, ringBuffer) 6769 decoder := json.NewDecoder(body) 6770 decoder.UseNumber() 6771 code, message, err := restjson.GetErrorInfo(decoder) 6772 if err != nil { 6773 var snapshot bytes.Buffer 6774 io.Copy(&snapshot, ringBuffer) 6775 err = &smithy.DeserializationError{ 6776 Err: fmt.Errorf("failed to decode response body, %w", err), 6777 Snapshot: snapshot.Bytes(), 6778 } 6779 return err 6780 } 6781 6782 errorBody.Seek(0, io.SeekStart) 6783 if len(code) != 0 { 6784 errorCode = restjson.SanitizeErrorCode(code) 6785 } 6786 if len(message) != 0 { 6787 errorMessage = message 6788 } 6789 6790 switch { 6791 case strings.EqualFold("BadRequestException", errorCode): 6792 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6793 6794 case strings.EqualFold("InternalServerErrorException", errorCode): 6795 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6796 6797 default: 6798 genericError := &smithy.GenericAPIError{ 6799 Code: errorCode, 6800 Message: errorMessage, 6801 } 6802 return genericError 6803 6804 } 6805} 6806 6807type awsRestjson1_deserializeOpUnarchiveFindings struct { 6808} 6809 6810func (*awsRestjson1_deserializeOpUnarchiveFindings) ID() string { 6811 return "OperationDeserializer" 6812} 6813 6814func (m *awsRestjson1_deserializeOpUnarchiveFindings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6815 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6816) { 6817 out, metadata, err = next.HandleDeserialize(ctx, in) 6818 if err != nil { 6819 return out, metadata, err 6820 } 6821 6822 response, ok := out.RawResponse.(*smithyhttp.Response) 6823 if !ok { 6824 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6825 } 6826 6827 if response.StatusCode < 200 || response.StatusCode >= 300 { 6828 return out, metadata, awsRestjson1_deserializeOpErrorUnarchiveFindings(response, &metadata) 6829 } 6830 output := &UnarchiveFindingsOutput{} 6831 out.Result = output 6832 6833 return out, metadata, err 6834} 6835 6836func awsRestjson1_deserializeOpErrorUnarchiveFindings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6837 var errorBuffer bytes.Buffer 6838 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6839 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6840 } 6841 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6842 6843 errorCode := "UnknownError" 6844 errorMessage := errorCode 6845 6846 code := response.Header.Get("X-Amzn-ErrorType") 6847 if len(code) != 0 { 6848 errorCode = restjson.SanitizeErrorCode(code) 6849 } 6850 6851 var buff [1024]byte 6852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6853 6854 body := io.TeeReader(errorBody, ringBuffer) 6855 decoder := json.NewDecoder(body) 6856 decoder.UseNumber() 6857 code, message, err := restjson.GetErrorInfo(decoder) 6858 if err != nil { 6859 var snapshot bytes.Buffer 6860 io.Copy(&snapshot, ringBuffer) 6861 err = &smithy.DeserializationError{ 6862 Err: fmt.Errorf("failed to decode response body, %w", err), 6863 Snapshot: snapshot.Bytes(), 6864 } 6865 return err 6866 } 6867 6868 errorBody.Seek(0, io.SeekStart) 6869 if len(code) != 0 { 6870 errorCode = restjson.SanitizeErrorCode(code) 6871 } 6872 if len(message) != 0 { 6873 errorMessage = message 6874 } 6875 6876 switch { 6877 case strings.EqualFold("BadRequestException", errorCode): 6878 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6879 6880 case strings.EqualFold("InternalServerErrorException", errorCode): 6881 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6882 6883 default: 6884 genericError := &smithy.GenericAPIError{ 6885 Code: errorCode, 6886 Message: errorMessage, 6887 } 6888 return genericError 6889 6890 } 6891} 6892 6893type awsRestjson1_deserializeOpUntagResource struct { 6894} 6895 6896func (*awsRestjson1_deserializeOpUntagResource) ID() string { 6897 return "OperationDeserializer" 6898} 6899 6900func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6901 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6902) { 6903 out, metadata, err = next.HandleDeserialize(ctx, in) 6904 if err != nil { 6905 return out, metadata, err 6906 } 6907 6908 response, ok := out.RawResponse.(*smithyhttp.Response) 6909 if !ok { 6910 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6911 } 6912 6913 if response.StatusCode < 200 || response.StatusCode >= 300 { 6914 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 6915 } 6916 output := &UntagResourceOutput{} 6917 out.Result = output 6918 6919 return out, metadata, err 6920} 6921 6922func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6923 var errorBuffer bytes.Buffer 6924 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6925 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6926 } 6927 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6928 6929 errorCode := "UnknownError" 6930 errorMessage := errorCode 6931 6932 code := response.Header.Get("X-Amzn-ErrorType") 6933 if len(code) != 0 { 6934 errorCode = restjson.SanitizeErrorCode(code) 6935 } 6936 6937 var buff [1024]byte 6938 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6939 6940 body := io.TeeReader(errorBody, ringBuffer) 6941 decoder := json.NewDecoder(body) 6942 decoder.UseNumber() 6943 code, message, err := restjson.GetErrorInfo(decoder) 6944 if err != nil { 6945 var snapshot bytes.Buffer 6946 io.Copy(&snapshot, ringBuffer) 6947 err = &smithy.DeserializationError{ 6948 Err: fmt.Errorf("failed to decode response body, %w", err), 6949 Snapshot: snapshot.Bytes(), 6950 } 6951 return err 6952 } 6953 6954 errorBody.Seek(0, io.SeekStart) 6955 if len(code) != 0 { 6956 errorCode = restjson.SanitizeErrorCode(code) 6957 } 6958 if len(message) != 0 { 6959 errorMessage = message 6960 } 6961 6962 switch { 6963 case strings.EqualFold("BadRequestException", errorCode): 6964 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 6965 6966 case strings.EqualFold("InternalServerErrorException", errorCode): 6967 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 6968 6969 default: 6970 genericError := &smithy.GenericAPIError{ 6971 Code: errorCode, 6972 Message: errorMessage, 6973 } 6974 return genericError 6975 6976 } 6977} 6978 6979type awsRestjson1_deserializeOpUpdateDetector struct { 6980} 6981 6982func (*awsRestjson1_deserializeOpUpdateDetector) ID() string { 6983 return "OperationDeserializer" 6984} 6985 6986func (m *awsRestjson1_deserializeOpUpdateDetector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6988) { 6989 out, metadata, err = next.HandleDeserialize(ctx, in) 6990 if err != nil { 6991 return out, metadata, err 6992 } 6993 6994 response, ok := out.RawResponse.(*smithyhttp.Response) 6995 if !ok { 6996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6997 } 6998 6999 if response.StatusCode < 200 || response.StatusCode >= 300 { 7000 return out, metadata, awsRestjson1_deserializeOpErrorUpdateDetector(response, &metadata) 7001 } 7002 output := &UpdateDetectorOutput{} 7003 out.Result = output 7004 7005 return out, metadata, err 7006} 7007 7008func awsRestjson1_deserializeOpErrorUpdateDetector(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7009 var errorBuffer bytes.Buffer 7010 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7011 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7012 } 7013 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7014 7015 errorCode := "UnknownError" 7016 errorMessage := errorCode 7017 7018 code := response.Header.Get("X-Amzn-ErrorType") 7019 if len(code) != 0 { 7020 errorCode = restjson.SanitizeErrorCode(code) 7021 } 7022 7023 var buff [1024]byte 7024 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7025 7026 body := io.TeeReader(errorBody, ringBuffer) 7027 decoder := json.NewDecoder(body) 7028 decoder.UseNumber() 7029 code, message, err := restjson.GetErrorInfo(decoder) 7030 if err != nil { 7031 var snapshot bytes.Buffer 7032 io.Copy(&snapshot, ringBuffer) 7033 err = &smithy.DeserializationError{ 7034 Err: fmt.Errorf("failed to decode response body, %w", err), 7035 Snapshot: snapshot.Bytes(), 7036 } 7037 return err 7038 } 7039 7040 errorBody.Seek(0, io.SeekStart) 7041 if len(code) != 0 { 7042 errorCode = restjson.SanitizeErrorCode(code) 7043 } 7044 if len(message) != 0 { 7045 errorMessage = message 7046 } 7047 7048 switch { 7049 case strings.EqualFold("BadRequestException", errorCode): 7050 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7051 7052 case strings.EqualFold("InternalServerErrorException", errorCode): 7053 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7054 7055 default: 7056 genericError := &smithy.GenericAPIError{ 7057 Code: errorCode, 7058 Message: errorMessage, 7059 } 7060 return genericError 7061 7062 } 7063} 7064 7065type awsRestjson1_deserializeOpUpdateFilter struct { 7066} 7067 7068func (*awsRestjson1_deserializeOpUpdateFilter) ID() string { 7069 return "OperationDeserializer" 7070} 7071 7072func (m *awsRestjson1_deserializeOpUpdateFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7073 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7074) { 7075 out, metadata, err = next.HandleDeserialize(ctx, in) 7076 if err != nil { 7077 return out, metadata, err 7078 } 7079 7080 response, ok := out.RawResponse.(*smithyhttp.Response) 7081 if !ok { 7082 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7083 } 7084 7085 if response.StatusCode < 200 || response.StatusCode >= 300 { 7086 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFilter(response, &metadata) 7087 } 7088 output := &UpdateFilterOutput{} 7089 out.Result = output 7090 7091 var buff [1024]byte 7092 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7093 7094 body := io.TeeReader(response.Body, ringBuffer) 7095 7096 decoder := json.NewDecoder(body) 7097 decoder.UseNumber() 7098 var shape interface{} 7099 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7100 var snapshot bytes.Buffer 7101 io.Copy(&snapshot, ringBuffer) 7102 err = &smithy.DeserializationError{ 7103 Err: fmt.Errorf("failed to decode response body, %w", err), 7104 Snapshot: snapshot.Bytes(), 7105 } 7106 return out, metadata, err 7107 } 7108 7109 err = awsRestjson1_deserializeOpDocumentUpdateFilterOutput(&output, shape) 7110 if err != nil { 7111 var snapshot bytes.Buffer 7112 io.Copy(&snapshot, ringBuffer) 7113 return out, metadata, &smithy.DeserializationError{ 7114 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7115 Snapshot: snapshot.Bytes(), 7116 } 7117 } 7118 7119 return out, metadata, err 7120} 7121 7122func awsRestjson1_deserializeOpErrorUpdateFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7123 var errorBuffer bytes.Buffer 7124 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7125 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7126 } 7127 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7128 7129 errorCode := "UnknownError" 7130 errorMessage := errorCode 7131 7132 code := response.Header.Get("X-Amzn-ErrorType") 7133 if len(code) != 0 { 7134 errorCode = restjson.SanitizeErrorCode(code) 7135 } 7136 7137 var buff [1024]byte 7138 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7139 7140 body := io.TeeReader(errorBody, ringBuffer) 7141 decoder := json.NewDecoder(body) 7142 decoder.UseNumber() 7143 code, message, err := restjson.GetErrorInfo(decoder) 7144 if err != nil { 7145 var snapshot bytes.Buffer 7146 io.Copy(&snapshot, ringBuffer) 7147 err = &smithy.DeserializationError{ 7148 Err: fmt.Errorf("failed to decode response body, %w", err), 7149 Snapshot: snapshot.Bytes(), 7150 } 7151 return err 7152 } 7153 7154 errorBody.Seek(0, io.SeekStart) 7155 if len(code) != 0 { 7156 errorCode = restjson.SanitizeErrorCode(code) 7157 } 7158 if len(message) != 0 { 7159 errorMessage = message 7160 } 7161 7162 switch { 7163 case strings.EqualFold("BadRequestException", errorCode): 7164 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7165 7166 case strings.EqualFold("InternalServerErrorException", errorCode): 7167 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7168 7169 default: 7170 genericError := &smithy.GenericAPIError{ 7171 Code: errorCode, 7172 Message: errorMessage, 7173 } 7174 return genericError 7175 7176 } 7177} 7178 7179func awsRestjson1_deserializeOpDocumentUpdateFilterOutput(v **UpdateFilterOutput, value interface{}) error { 7180 if v == nil { 7181 return fmt.Errorf("unexpected nil of type %T", v) 7182 } 7183 if value == nil { 7184 return nil 7185 } 7186 7187 shape, ok := value.(map[string]interface{}) 7188 if !ok { 7189 return fmt.Errorf("unexpected JSON type %v", value) 7190 } 7191 7192 var sv *UpdateFilterOutput 7193 if *v == nil { 7194 sv = &UpdateFilterOutput{} 7195 } else { 7196 sv = *v 7197 } 7198 7199 for key, value := range shape { 7200 switch key { 7201 case "name": 7202 if value != nil { 7203 jtv, ok := value.(string) 7204 if !ok { 7205 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 7206 } 7207 sv.Name = ptr.String(jtv) 7208 } 7209 7210 default: 7211 _, _ = key, value 7212 7213 } 7214 } 7215 *v = sv 7216 return nil 7217} 7218 7219type awsRestjson1_deserializeOpUpdateFindingsFeedback struct { 7220} 7221 7222func (*awsRestjson1_deserializeOpUpdateFindingsFeedback) ID() string { 7223 return "OperationDeserializer" 7224} 7225 7226func (m *awsRestjson1_deserializeOpUpdateFindingsFeedback) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7227 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7228) { 7229 out, metadata, err = next.HandleDeserialize(ctx, in) 7230 if err != nil { 7231 return out, metadata, err 7232 } 7233 7234 response, ok := out.RawResponse.(*smithyhttp.Response) 7235 if !ok { 7236 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7237 } 7238 7239 if response.StatusCode < 200 || response.StatusCode >= 300 { 7240 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFindingsFeedback(response, &metadata) 7241 } 7242 output := &UpdateFindingsFeedbackOutput{} 7243 out.Result = output 7244 7245 return out, metadata, err 7246} 7247 7248func awsRestjson1_deserializeOpErrorUpdateFindingsFeedback(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7249 var errorBuffer bytes.Buffer 7250 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7251 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7252 } 7253 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7254 7255 errorCode := "UnknownError" 7256 errorMessage := errorCode 7257 7258 code := response.Header.Get("X-Amzn-ErrorType") 7259 if len(code) != 0 { 7260 errorCode = restjson.SanitizeErrorCode(code) 7261 } 7262 7263 var buff [1024]byte 7264 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7265 7266 body := io.TeeReader(errorBody, ringBuffer) 7267 decoder := json.NewDecoder(body) 7268 decoder.UseNumber() 7269 code, message, err := restjson.GetErrorInfo(decoder) 7270 if err != nil { 7271 var snapshot bytes.Buffer 7272 io.Copy(&snapshot, ringBuffer) 7273 err = &smithy.DeserializationError{ 7274 Err: fmt.Errorf("failed to decode response body, %w", err), 7275 Snapshot: snapshot.Bytes(), 7276 } 7277 return err 7278 } 7279 7280 errorBody.Seek(0, io.SeekStart) 7281 if len(code) != 0 { 7282 errorCode = restjson.SanitizeErrorCode(code) 7283 } 7284 if len(message) != 0 { 7285 errorMessage = message 7286 } 7287 7288 switch { 7289 case strings.EqualFold("BadRequestException", errorCode): 7290 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7291 7292 case strings.EqualFold("InternalServerErrorException", errorCode): 7293 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7294 7295 default: 7296 genericError := &smithy.GenericAPIError{ 7297 Code: errorCode, 7298 Message: errorMessage, 7299 } 7300 return genericError 7301 7302 } 7303} 7304 7305type awsRestjson1_deserializeOpUpdateIPSet struct { 7306} 7307 7308func (*awsRestjson1_deserializeOpUpdateIPSet) ID() string { 7309 return "OperationDeserializer" 7310} 7311 7312func (m *awsRestjson1_deserializeOpUpdateIPSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7313 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7314) { 7315 out, metadata, err = next.HandleDeserialize(ctx, in) 7316 if err != nil { 7317 return out, metadata, err 7318 } 7319 7320 response, ok := out.RawResponse.(*smithyhttp.Response) 7321 if !ok { 7322 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7323 } 7324 7325 if response.StatusCode < 200 || response.StatusCode >= 300 { 7326 return out, metadata, awsRestjson1_deserializeOpErrorUpdateIPSet(response, &metadata) 7327 } 7328 output := &UpdateIPSetOutput{} 7329 out.Result = output 7330 7331 return out, metadata, err 7332} 7333 7334func awsRestjson1_deserializeOpErrorUpdateIPSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7335 var errorBuffer bytes.Buffer 7336 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7337 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7338 } 7339 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7340 7341 errorCode := "UnknownError" 7342 errorMessage := errorCode 7343 7344 code := response.Header.Get("X-Amzn-ErrorType") 7345 if len(code) != 0 { 7346 errorCode = restjson.SanitizeErrorCode(code) 7347 } 7348 7349 var buff [1024]byte 7350 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7351 7352 body := io.TeeReader(errorBody, ringBuffer) 7353 decoder := json.NewDecoder(body) 7354 decoder.UseNumber() 7355 code, message, err := restjson.GetErrorInfo(decoder) 7356 if err != nil { 7357 var snapshot bytes.Buffer 7358 io.Copy(&snapshot, ringBuffer) 7359 err = &smithy.DeserializationError{ 7360 Err: fmt.Errorf("failed to decode response body, %w", err), 7361 Snapshot: snapshot.Bytes(), 7362 } 7363 return err 7364 } 7365 7366 errorBody.Seek(0, io.SeekStart) 7367 if len(code) != 0 { 7368 errorCode = restjson.SanitizeErrorCode(code) 7369 } 7370 if len(message) != 0 { 7371 errorMessage = message 7372 } 7373 7374 switch { 7375 case strings.EqualFold("BadRequestException", errorCode): 7376 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7377 7378 case strings.EqualFold("InternalServerErrorException", errorCode): 7379 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7380 7381 default: 7382 genericError := &smithy.GenericAPIError{ 7383 Code: errorCode, 7384 Message: errorMessage, 7385 } 7386 return genericError 7387 7388 } 7389} 7390 7391type awsRestjson1_deserializeOpUpdateMemberDetectors struct { 7392} 7393 7394func (*awsRestjson1_deserializeOpUpdateMemberDetectors) ID() string { 7395 return "OperationDeserializer" 7396} 7397 7398func (m *awsRestjson1_deserializeOpUpdateMemberDetectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7399 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7400) { 7401 out, metadata, err = next.HandleDeserialize(ctx, in) 7402 if err != nil { 7403 return out, metadata, err 7404 } 7405 7406 response, ok := out.RawResponse.(*smithyhttp.Response) 7407 if !ok { 7408 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7409 } 7410 7411 if response.StatusCode < 200 || response.StatusCode >= 300 { 7412 return out, metadata, awsRestjson1_deserializeOpErrorUpdateMemberDetectors(response, &metadata) 7413 } 7414 output := &UpdateMemberDetectorsOutput{} 7415 out.Result = output 7416 7417 var buff [1024]byte 7418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7419 7420 body := io.TeeReader(response.Body, ringBuffer) 7421 7422 decoder := json.NewDecoder(body) 7423 decoder.UseNumber() 7424 var shape interface{} 7425 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7426 var snapshot bytes.Buffer 7427 io.Copy(&snapshot, ringBuffer) 7428 err = &smithy.DeserializationError{ 7429 Err: fmt.Errorf("failed to decode response body, %w", err), 7430 Snapshot: snapshot.Bytes(), 7431 } 7432 return out, metadata, err 7433 } 7434 7435 err = awsRestjson1_deserializeOpDocumentUpdateMemberDetectorsOutput(&output, shape) 7436 if err != nil { 7437 var snapshot bytes.Buffer 7438 io.Copy(&snapshot, ringBuffer) 7439 return out, metadata, &smithy.DeserializationError{ 7440 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7441 Snapshot: snapshot.Bytes(), 7442 } 7443 } 7444 7445 return out, metadata, err 7446} 7447 7448func awsRestjson1_deserializeOpErrorUpdateMemberDetectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7449 var errorBuffer bytes.Buffer 7450 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7451 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7452 } 7453 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7454 7455 errorCode := "UnknownError" 7456 errorMessage := errorCode 7457 7458 code := response.Header.Get("X-Amzn-ErrorType") 7459 if len(code) != 0 { 7460 errorCode = restjson.SanitizeErrorCode(code) 7461 } 7462 7463 var buff [1024]byte 7464 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7465 7466 body := io.TeeReader(errorBody, ringBuffer) 7467 decoder := json.NewDecoder(body) 7468 decoder.UseNumber() 7469 code, message, err := restjson.GetErrorInfo(decoder) 7470 if err != nil { 7471 var snapshot bytes.Buffer 7472 io.Copy(&snapshot, ringBuffer) 7473 err = &smithy.DeserializationError{ 7474 Err: fmt.Errorf("failed to decode response body, %w", err), 7475 Snapshot: snapshot.Bytes(), 7476 } 7477 return err 7478 } 7479 7480 errorBody.Seek(0, io.SeekStart) 7481 if len(code) != 0 { 7482 errorCode = restjson.SanitizeErrorCode(code) 7483 } 7484 if len(message) != 0 { 7485 errorMessage = message 7486 } 7487 7488 switch { 7489 case strings.EqualFold("BadRequestException", errorCode): 7490 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7491 7492 case strings.EqualFold("InternalServerErrorException", errorCode): 7493 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7494 7495 default: 7496 genericError := &smithy.GenericAPIError{ 7497 Code: errorCode, 7498 Message: errorMessage, 7499 } 7500 return genericError 7501 7502 } 7503} 7504 7505func awsRestjson1_deserializeOpDocumentUpdateMemberDetectorsOutput(v **UpdateMemberDetectorsOutput, value interface{}) error { 7506 if v == nil { 7507 return fmt.Errorf("unexpected nil of type %T", v) 7508 } 7509 if value == nil { 7510 return nil 7511 } 7512 7513 shape, ok := value.(map[string]interface{}) 7514 if !ok { 7515 return fmt.Errorf("unexpected JSON type %v", value) 7516 } 7517 7518 var sv *UpdateMemberDetectorsOutput 7519 if *v == nil { 7520 sv = &UpdateMemberDetectorsOutput{} 7521 } else { 7522 sv = *v 7523 } 7524 7525 for key, value := range shape { 7526 switch key { 7527 case "unprocessedAccounts": 7528 if err := awsRestjson1_deserializeDocumentUnprocessedAccounts(&sv.UnprocessedAccounts, value); err != nil { 7529 return err 7530 } 7531 7532 default: 7533 _, _ = key, value 7534 7535 } 7536 } 7537 *v = sv 7538 return nil 7539} 7540 7541type awsRestjson1_deserializeOpUpdateOrganizationConfiguration struct { 7542} 7543 7544func (*awsRestjson1_deserializeOpUpdateOrganizationConfiguration) ID() string { 7545 return "OperationDeserializer" 7546} 7547 7548func (m *awsRestjson1_deserializeOpUpdateOrganizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7549 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7550) { 7551 out, metadata, err = next.HandleDeserialize(ctx, in) 7552 if err != nil { 7553 return out, metadata, err 7554 } 7555 7556 response, ok := out.RawResponse.(*smithyhttp.Response) 7557 if !ok { 7558 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7559 } 7560 7561 if response.StatusCode < 200 || response.StatusCode >= 300 { 7562 return out, metadata, awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response, &metadata) 7563 } 7564 output := &UpdateOrganizationConfigurationOutput{} 7565 out.Result = output 7566 7567 return out, metadata, err 7568} 7569 7570func awsRestjson1_deserializeOpErrorUpdateOrganizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7571 var errorBuffer bytes.Buffer 7572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7574 } 7575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7576 7577 errorCode := "UnknownError" 7578 errorMessage := errorCode 7579 7580 code := response.Header.Get("X-Amzn-ErrorType") 7581 if len(code) != 0 { 7582 errorCode = restjson.SanitizeErrorCode(code) 7583 } 7584 7585 var buff [1024]byte 7586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7587 7588 body := io.TeeReader(errorBody, ringBuffer) 7589 decoder := json.NewDecoder(body) 7590 decoder.UseNumber() 7591 code, message, err := restjson.GetErrorInfo(decoder) 7592 if err != nil { 7593 var snapshot bytes.Buffer 7594 io.Copy(&snapshot, ringBuffer) 7595 err = &smithy.DeserializationError{ 7596 Err: fmt.Errorf("failed to decode response body, %w", err), 7597 Snapshot: snapshot.Bytes(), 7598 } 7599 return err 7600 } 7601 7602 errorBody.Seek(0, io.SeekStart) 7603 if len(code) != 0 { 7604 errorCode = restjson.SanitizeErrorCode(code) 7605 } 7606 if len(message) != 0 { 7607 errorMessage = message 7608 } 7609 7610 switch { 7611 case strings.EqualFold("BadRequestException", errorCode): 7612 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7613 7614 case strings.EqualFold("InternalServerErrorException", errorCode): 7615 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7616 7617 default: 7618 genericError := &smithy.GenericAPIError{ 7619 Code: errorCode, 7620 Message: errorMessage, 7621 } 7622 return genericError 7623 7624 } 7625} 7626 7627type awsRestjson1_deserializeOpUpdatePublishingDestination struct { 7628} 7629 7630func (*awsRestjson1_deserializeOpUpdatePublishingDestination) ID() string { 7631 return "OperationDeserializer" 7632} 7633 7634func (m *awsRestjson1_deserializeOpUpdatePublishingDestination) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7636) { 7637 out, metadata, err = next.HandleDeserialize(ctx, in) 7638 if err != nil { 7639 return out, metadata, err 7640 } 7641 7642 response, ok := out.RawResponse.(*smithyhttp.Response) 7643 if !ok { 7644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7645 } 7646 7647 if response.StatusCode < 200 || response.StatusCode >= 300 { 7648 return out, metadata, awsRestjson1_deserializeOpErrorUpdatePublishingDestination(response, &metadata) 7649 } 7650 output := &UpdatePublishingDestinationOutput{} 7651 out.Result = output 7652 7653 return out, metadata, err 7654} 7655 7656func awsRestjson1_deserializeOpErrorUpdatePublishingDestination(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7657 var errorBuffer bytes.Buffer 7658 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7659 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7660 } 7661 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7662 7663 errorCode := "UnknownError" 7664 errorMessage := errorCode 7665 7666 code := response.Header.Get("X-Amzn-ErrorType") 7667 if len(code) != 0 { 7668 errorCode = restjson.SanitizeErrorCode(code) 7669 } 7670 7671 var buff [1024]byte 7672 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7673 7674 body := io.TeeReader(errorBody, ringBuffer) 7675 decoder := json.NewDecoder(body) 7676 decoder.UseNumber() 7677 code, message, err := restjson.GetErrorInfo(decoder) 7678 if err != nil { 7679 var snapshot bytes.Buffer 7680 io.Copy(&snapshot, ringBuffer) 7681 err = &smithy.DeserializationError{ 7682 Err: fmt.Errorf("failed to decode response body, %w", err), 7683 Snapshot: snapshot.Bytes(), 7684 } 7685 return err 7686 } 7687 7688 errorBody.Seek(0, io.SeekStart) 7689 if len(code) != 0 { 7690 errorCode = restjson.SanitizeErrorCode(code) 7691 } 7692 if len(message) != 0 { 7693 errorMessage = message 7694 } 7695 7696 switch { 7697 case strings.EqualFold("BadRequestException", errorCode): 7698 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7699 7700 case strings.EqualFold("InternalServerErrorException", errorCode): 7701 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7702 7703 default: 7704 genericError := &smithy.GenericAPIError{ 7705 Code: errorCode, 7706 Message: errorMessage, 7707 } 7708 return genericError 7709 7710 } 7711} 7712 7713type awsRestjson1_deserializeOpUpdateThreatIntelSet struct { 7714} 7715 7716func (*awsRestjson1_deserializeOpUpdateThreatIntelSet) ID() string { 7717 return "OperationDeserializer" 7718} 7719 7720func (m *awsRestjson1_deserializeOpUpdateThreatIntelSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7721 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7722) { 7723 out, metadata, err = next.HandleDeserialize(ctx, in) 7724 if err != nil { 7725 return out, metadata, err 7726 } 7727 7728 response, ok := out.RawResponse.(*smithyhttp.Response) 7729 if !ok { 7730 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7731 } 7732 7733 if response.StatusCode < 200 || response.StatusCode >= 300 { 7734 return out, metadata, awsRestjson1_deserializeOpErrorUpdateThreatIntelSet(response, &metadata) 7735 } 7736 output := &UpdateThreatIntelSetOutput{} 7737 out.Result = output 7738 7739 return out, metadata, err 7740} 7741 7742func awsRestjson1_deserializeOpErrorUpdateThreatIntelSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7743 var errorBuffer bytes.Buffer 7744 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7745 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7746 } 7747 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7748 7749 errorCode := "UnknownError" 7750 errorMessage := errorCode 7751 7752 code := response.Header.Get("X-Amzn-ErrorType") 7753 if len(code) != 0 { 7754 errorCode = restjson.SanitizeErrorCode(code) 7755 } 7756 7757 var buff [1024]byte 7758 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7759 7760 body := io.TeeReader(errorBody, ringBuffer) 7761 decoder := json.NewDecoder(body) 7762 decoder.UseNumber() 7763 code, message, err := restjson.GetErrorInfo(decoder) 7764 if err != nil { 7765 var snapshot bytes.Buffer 7766 io.Copy(&snapshot, ringBuffer) 7767 err = &smithy.DeserializationError{ 7768 Err: fmt.Errorf("failed to decode response body, %w", err), 7769 Snapshot: snapshot.Bytes(), 7770 } 7771 return err 7772 } 7773 7774 errorBody.Seek(0, io.SeekStart) 7775 if len(code) != 0 { 7776 errorCode = restjson.SanitizeErrorCode(code) 7777 } 7778 if len(message) != 0 { 7779 errorMessage = message 7780 } 7781 7782 switch { 7783 case strings.EqualFold("BadRequestException", errorCode): 7784 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 7785 7786 case strings.EqualFold("InternalServerErrorException", errorCode): 7787 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 7788 7789 default: 7790 genericError := &smithy.GenericAPIError{ 7791 Code: errorCode, 7792 Message: errorMessage, 7793 } 7794 return genericError 7795 7796 } 7797} 7798 7799func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7800 output := &types.BadRequestException{} 7801 var buff [1024]byte 7802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7803 7804 body := io.TeeReader(errorBody, ringBuffer) 7805 decoder := json.NewDecoder(body) 7806 decoder.UseNumber() 7807 var shape interface{} 7808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7809 var snapshot bytes.Buffer 7810 io.Copy(&snapshot, ringBuffer) 7811 err = &smithy.DeserializationError{ 7812 Err: fmt.Errorf("failed to decode response body, %w", err), 7813 Snapshot: snapshot.Bytes(), 7814 } 7815 return err 7816 } 7817 7818 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 7819 7820 if err != nil { 7821 var snapshot bytes.Buffer 7822 io.Copy(&snapshot, ringBuffer) 7823 err = &smithy.DeserializationError{ 7824 Err: fmt.Errorf("failed to decode response body, %w", err), 7825 Snapshot: snapshot.Bytes(), 7826 } 7827 return err 7828 } 7829 7830 errorBody.Seek(0, io.SeekStart) 7831 7832 return output 7833} 7834 7835func awsRestjson1_deserializeErrorInternalServerErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7836 output := &types.InternalServerErrorException{} 7837 var buff [1024]byte 7838 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7839 7840 body := io.TeeReader(errorBody, ringBuffer) 7841 decoder := json.NewDecoder(body) 7842 decoder.UseNumber() 7843 var shape interface{} 7844 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7845 var snapshot bytes.Buffer 7846 io.Copy(&snapshot, ringBuffer) 7847 err = &smithy.DeserializationError{ 7848 Err: fmt.Errorf("failed to decode response body, %w", err), 7849 Snapshot: snapshot.Bytes(), 7850 } 7851 return err 7852 } 7853 7854 err := awsRestjson1_deserializeDocumentInternalServerErrorException(&output, shape) 7855 7856 if err != nil { 7857 var snapshot bytes.Buffer 7858 io.Copy(&snapshot, ringBuffer) 7859 err = &smithy.DeserializationError{ 7860 Err: fmt.Errorf("failed to decode response body, %w", err), 7861 Snapshot: snapshot.Bytes(), 7862 } 7863 return err 7864 } 7865 7866 errorBody.Seek(0, io.SeekStart) 7867 7868 return output 7869} 7870 7871func awsRestjson1_deserializeDocumentAccessControlList(v **types.AccessControlList, value interface{}) error { 7872 if v == nil { 7873 return fmt.Errorf("unexpected nil of type %T", v) 7874 } 7875 if value == nil { 7876 return nil 7877 } 7878 7879 shape, ok := value.(map[string]interface{}) 7880 if !ok { 7881 return fmt.Errorf("unexpected JSON type %v", value) 7882 } 7883 7884 var sv *types.AccessControlList 7885 if *v == nil { 7886 sv = &types.AccessControlList{} 7887 } else { 7888 sv = *v 7889 } 7890 7891 for key, value := range shape { 7892 switch key { 7893 case "allowsPublicReadAccess": 7894 if value != nil { 7895 jtv, ok := value.(bool) 7896 if !ok { 7897 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7898 } 7899 sv.AllowsPublicReadAccess = jtv 7900 } 7901 7902 case "allowsPublicWriteAccess": 7903 if value != nil { 7904 jtv, ok := value.(bool) 7905 if !ok { 7906 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7907 } 7908 sv.AllowsPublicWriteAccess = jtv 7909 } 7910 7911 default: 7912 _, _ = key, value 7913 7914 } 7915 } 7916 *v = sv 7917 return nil 7918} 7919 7920func awsRestjson1_deserializeDocumentAccessKeyDetails(v **types.AccessKeyDetails, value interface{}) error { 7921 if v == nil { 7922 return fmt.Errorf("unexpected nil of type %T", v) 7923 } 7924 if value == nil { 7925 return nil 7926 } 7927 7928 shape, ok := value.(map[string]interface{}) 7929 if !ok { 7930 return fmt.Errorf("unexpected JSON type %v", value) 7931 } 7932 7933 var sv *types.AccessKeyDetails 7934 if *v == nil { 7935 sv = &types.AccessKeyDetails{} 7936 } else { 7937 sv = *v 7938 } 7939 7940 for key, value := range shape { 7941 switch key { 7942 case "accessKeyId": 7943 if value != nil { 7944 jtv, ok := value.(string) 7945 if !ok { 7946 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7947 } 7948 sv.AccessKeyId = ptr.String(jtv) 7949 } 7950 7951 case "principalId": 7952 if value != nil { 7953 jtv, ok := value.(string) 7954 if !ok { 7955 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7956 } 7957 sv.PrincipalId = ptr.String(jtv) 7958 } 7959 7960 case "userName": 7961 if value != nil { 7962 jtv, ok := value.(string) 7963 if !ok { 7964 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7965 } 7966 sv.UserName = ptr.String(jtv) 7967 } 7968 7969 case "userType": 7970 if value != nil { 7971 jtv, ok := value.(string) 7972 if !ok { 7973 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7974 } 7975 sv.UserType = ptr.String(jtv) 7976 } 7977 7978 default: 7979 _, _ = key, value 7980 7981 } 7982 } 7983 *v = sv 7984 return nil 7985} 7986 7987func awsRestjson1_deserializeDocumentAccountLevelPermissions(v **types.AccountLevelPermissions, value interface{}) error { 7988 if v == nil { 7989 return fmt.Errorf("unexpected nil of type %T", v) 7990 } 7991 if value == nil { 7992 return nil 7993 } 7994 7995 shape, ok := value.(map[string]interface{}) 7996 if !ok { 7997 return fmt.Errorf("unexpected JSON type %v", value) 7998 } 7999 8000 var sv *types.AccountLevelPermissions 8001 if *v == nil { 8002 sv = &types.AccountLevelPermissions{} 8003 } else { 8004 sv = *v 8005 } 8006 8007 for key, value := range shape { 8008 switch key { 8009 case "blockPublicAccess": 8010 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 8011 return err 8012 } 8013 8014 default: 8015 _, _ = key, value 8016 8017 } 8018 } 8019 *v = sv 8020 return nil 8021} 8022 8023func awsRestjson1_deserializeDocumentAction(v **types.Action, value interface{}) error { 8024 if v == nil { 8025 return fmt.Errorf("unexpected nil of type %T", v) 8026 } 8027 if value == nil { 8028 return nil 8029 } 8030 8031 shape, ok := value.(map[string]interface{}) 8032 if !ok { 8033 return fmt.Errorf("unexpected JSON type %v", value) 8034 } 8035 8036 var sv *types.Action 8037 if *v == nil { 8038 sv = &types.Action{} 8039 } else { 8040 sv = *v 8041 } 8042 8043 for key, value := range shape { 8044 switch key { 8045 case "actionType": 8046 if value != nil { 8047 jtv, ok := value.(string) 8048 if !ok { 8049 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8050 } 8051 sv.ActionType = ptr.String(jtv) 8052 } 8053 8054 case "awsApiCallAction": 8055 if err := awsRestjson1_deserializeDocumentAwsApiCallAction(&sv.AwsApiCallAction, value); err != nil { 8056 return err 8057 } 8058 8059 case "dnsRequestAction": 8060 if err := awsRestjson1_deserializeDocumentDnsRequestAction(&sv.DnsRequestAction, value); err != nil { 8061 return err 8062 } 8063 8064 case "networkConnectionAction": 8065 if err := awsRestjson1_deserializeDocumentNetworkConnectionAction(&sv.NetworkConnectionAction, value); err != nil { 8066 return err 8067 } 8068 8069 case "portProbeAction": 8070 if err := awsRestjson1_deserializeDocumentPortProbeAction(&sv.PortProbeAction, value); err != nil { 8071 return err 8072 } 8073 8074 default: 8075 _, _ = key, value 8076 8077 } 8078 } 8079 *v = sv 8080 return nil 8081} 8082 8083func awsRestjson1_deserializeDocumentAdminAccount(v **types.AdminAccount, value interface{}) error { 8084 if v == nil { 8085 return fmt.Errorf("unexpected nil of type %T", v) 8086 } 8087 if value == nil { 8088 return nil 8089 } 8090 8091 shape, ok := value.(map[string]interface{}) 8092 if !ok { 8093 return fmt.Errorf("unexpected JSON type %v", value) 8094 } 8095 8096 var sv *types.AdminAccount 8097 if *v == nil { 8098 sv = &types.AdminAccount{} 8099 } else { 8100 sv = *v 8101 } 8102 8103 for key, value := range shape { 8104 switch key { 8105 case "adminAccountId": 8106 if value != nil { 8107 jtv, ok := value.(string) 8108 if !ok { 8109 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8110 } 8111 sv.AdminAccountId = ptr.String(jtv) 8112 } 8113 8114 case "adminStatus": 8115 if value != nil { 8116 jtv, ok := value.(string) 8117 if !ok { 8118 return fmt.Errorf("expected AdminStatus to be of type string, got %T instead", value) 8119 } 8120 sv.AdminStatus = types.AdminStatus(jtv) 8121 } 8122 8123 default: 8124 _, _ = key, value 8125 8126 } 8127 } 8128 *v = sv 8129 return nil 8130} 8131 8132func awsRestjson1_deserializeDocumentAdminAccounts(v *[]types.AdminAccount, value interface{}) error { 8133 if v == nil { 8134 return fmt.Errorf("unexpected nil of type %T", v) 8135 } 8136 if value == nil { 8137 return nil 8138 } 8139 8140 shape, ok := value.([]interface{}) 8141 if !ok { 8142 return fmt.Errorf("unexpected JSON type %v", value) 8143 } 8144 8145 var cv []types.AdminAccount 8146 if *v == nil { 8147 cv = []types.AdminAccount{} 8148 } else { 8149 cv = *v 8150 } 8151 8152 for _, value := range shape { 8153 var col types.AdminAccount 8154 destAddr := &col 8155 if err := awsRestjson1_deserializeDocumentAdminAccount(&destAddr, value); err != nil { 8156 return err 8157 } 8158 col = *destAddr 8159 cv = append(cv, col) 8160 8161 } 8162 *v = cv 8163 return nil 8164} 8165 8166func awsRestjson1_deserializeDocumentAwsApiCallAction(v **types.AwsApiCallAction, value interface{}) error { 8167 if v == nil { 8168 return fmt.Errorf("unexpected nil of type %T", v) 8169 } 8170 if value == nil { 8171 return nil 8172 } 8173 8174 shape, ok := value.(map[string]interface{}) 8175 if !ok { 8176 return fmt.Errorf("unexpected JSON type %v", value) 8177 } 8178 8179 var sv *types.AwsApiCallAction 8180 if *v == nil { 8181 sv = &types.AwsApiCallAction{} 8182 } else { 8183 sv = *v 8184 } 8185 8186 for key, value := range shape { 8187 switch key { 8188 case "api": 8189 if value != nil { 8190 jtv, ok := value.(string) 8191 if !ok { 8192 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8193 } 8194 sv.Api = ptr.String(jtv) 8195 } 8196 8197 case "callerType": 8198 if value != nil { 8199 jtv, ok := value.(string) 8200 if !ok { 8201 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8202 } 8203 sv.CallerType = ptr.String(jtv) 8204 } 8205 8206 case "domainDetails": 8207 if err := awsRestjson1_deserializeDocumentDomainDetails(&sv.DomainDetails, value); err != nil { 8208 return err 8209 } 8210 8211 case "errorCode": 8212 if value != nil { 8213 jtv, ok := value.(string) 8214 if !ok { 8215 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8216 } 8217 sv.ErrorCode = ptr.String(jtv) 8218 } 8219 8220 case "remoteIpDetails": 8221 if err := awsRestjson1_deserializeDocumentRemoteIpDetails(&sv.RemoteIpDetails, value); err != nil { 8222 return err 8223 } 8224 8225 case "serviceName": 8226 if value != nil { 8227 jtv, ok := value.(string) 8228 if !ok { 8229 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8230 } 8231 sv.ServiceName = ptr.String(jtv) 8232 } 8233 8234 default: 8235 _, _ = key, value 8236 8237 } 8238 } 8239 *v = sv 8240 return nil 8241} 8242 8243func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 8244 if v == nil { 8245 return fmt.Errorf("unexpected nil of type %T", v) 8246 } 8247 if value == nil { 8248 return nil 8249 } 8250 8251 shape, ok := value.(map[string]interface{}) 8252 if !ok { 8253 return fmt.Errorf("unexpected JSON type %v", value) 8254 } 8255 8256 var sv *types.BadRequestException 8257 if *v == nil { 8258 sv = &types.BadRequestException{} 8259 } else { 8260 sv = *v 8261 } 8262 8263 for key, value := range shape { 8264 switch key { 8265 case "message": 8266 if value != nil { 8267 jtv, ok := value.(string) 8268 if !ok { 8269 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8270 } 8271 sv.Message = ptr.String(jtv) 8272 } 8273 8274 case "__type": 8275 if value != nil { 8276 jtv, ok := value.(string) 8277 if !ok { 8278 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8279 } 8280 sv.Type = ptr.String(jtv) 8281 } 8282 8283 default: 8284 _, _ = key, value 8285 8286 } 8287 } 8288 *v = sv 8289 return nil 8290} 8291 8292func awsRestjson1_deserializeDocumentBlockPublicAccess(v **types.BlockPublicAccess, value interface{}) error { 8293 if v == nil { 8294 return fmt.Errorf("unexpected nil of type %T", v) 8295 } 8296 if value == nil { 8297 return nil 8298 } 8299 8300 shape, ok := value.(map[string]interface{}) 8301 if !ok { 8302 return fmt.Errorf("unexpected JSON type %v", value) 8303 } 8304 8305 var sv *types.BlockPublicAccess 8306 if *v == nil { 8307 sv = &types.BlockPublicAccess{} 8308 } else { 8309 sv = *v 8310 } 8311 8312 for key, value := range shape { 8313 switch key { 8314 case "blockPublicAcls": 8315 if value != nil { 8316 jtv, ok := value.(bool) 8317 if !ok { 8318 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8319 } 8320 sv.BlockPublicAcls = jtv 8321 } 8322 8323 case "blockPublicPolicy": 8324 if value != nil { 8325 jtv, ok := value.(bool) 8326 if !ok { 8327 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8328 } 8329 sv.BlockPublicPolicy = jtv 8330 } 8331 8332 case "ignorePublicAcls": 8333 if value != nil { 8334 jtv, ok := value.(bool) 8335 if !ok { 8336 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8337 } 8338 sv.IgnorePublicAcls = jtv 8339 } 8340 8341 case "restrictPublicBuckets": 8342 if value != nil { 8343 jtv, ok := value.(bool) 8344 if !ok { 8345 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8346 } 8347 sv.RestrictPublicBuckets = jtv 8348 } 8349 8350 default: 8351 _, _ = key, value 8352 8353 } 8354 } 8355 *v = sv 8356 return nil 8357} 8358 8359func awsRestjson1_deserializeDocumentBucketLevelPermissions(v **types.BucketLevelPermissions, value interface{}) error { 8360 if v == nil { 8361 return fmt.Errorf("unexpected nil of type %T", v) 8362 } 8363 if value == nil { 8364 return nil 8365 } 8366 8367 shape, ok := value.(map[string]interface{}) 8368 if !ok { 8369 return fmt.Errorf("unexpected JSON type %v", value) 8370 } 8371 8372 var sv *types.BucketLevelPermissions 8373 if *v == nil { 8374 sv = &types.BucketLevelPermissions{} 8375 } else { 8376 sv = *v 8377 } 8378 8379 for key, value := range shape { 8380 switch key { 8381 case "accessControlList": 8382 if err := awsRestjson1_deserializeDocumentAccessControlList(&sv.AccessControlList, value); err != nil { 8383 return err 8384 } 8385 8386 case "blockPublicAccess": 8387 if err := awsRestjson1_deserializeDocumentBlockPublicAccess(&sv.BlockPublicAccess, value); err != nil { 8388 return err 8389 } 8390 8391 case "bucketPolicy": 8392 if err := awsRestjson1_deserializeDocumentBucketPolicy(&sv.BucketPolicy, value); err != nil { 8393 return err 8394 } 8395 8396 default: 8397 _, _ = key, value 8398 8399 } 8400 } 8401 *v = sv 8402 return nil 8403} 8404 8405func awsRestjson1_deserializeDocumentBucketPolicy(v **types.BucketPolicy, value interface{}) error { 8406 if v == nil { 8407 return fmt.Errorf("unexpected nil of type %T", v) 8408 } 8409 if value == nil { 8410 return nil 8411 } 8412 8413 shape, ok := value.(map[string]interface{}) 8414 if !ok { 8415 return fmt.Errorf("unexpected JSON type %v", value) 8416 } 8417 8418 var sv *types.BucketPolicy 8419 if *v == nil { 8420 sv = &types.BucketPolicy{} 8421 } else { 8422 sv = *v 8423 } 8424 8425 for key, value := range shape { 8426 switch key { 8427 case "allowsPublicReadAccess": 8428 if value != nil { 8429 jtv, ok := value.(bool) 8430 if !ok { 8431 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8432 } 8433 sv.AllowsPublicReadAccess = jtv 8434 } 8435 8436 case "allowsPublicWriteAccess": 8437 if value != nil { 8438 jtv, ok := value.(bool) 8439 if !ok { 8440 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 8441 } 8442 sv.AllowsPublicWriteAccess = jtv 8443 } 8444 8445 default: 8446 _, _ = key, value 8447 8448 } 8449 } 8450 *v = sv 8451 return nil 8452} 8453 8454func awsRestjson1_deserializeDocumentCity(v **types.City, value interface{}) error { 8455 if v == nil { 8456 return fmt.Errorf("unexpected nil of type %T", v) 8457 } 8458 if value == nil { 8459 return nil 8460 } 8461 8462 shape, ok := value.(map[string]interface{}) 8463 if !ok { 8464 return fmt.Errorf("unexpected JSON type %v", value) 8465 } 8466 8467 var sv *types.City 8468 if *v == nil { 8469 sv = &types.City{} 8470 } else { 8471 sv = *v 8472 } 8473 8474 for key, value := range shape { 8475 switch key { 8476 case "cityName": 8477 if value != nil { 8478 jtv, ok := value.(string) 8479 if !ok { 8480 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8481 } 8482 sv.CityName = ptr.String(jtv) 8483 } 8484 8485 default: 8486 _, _ = key, value 8487 8488 } 8489 } 8490 *v = sv 8491 return nil 8492} 8493 8494func awsRestjson1_deserializeDocumentCloudTrailConfigurationResult(v **types.CloudTrailConfigurationResult, value interface{}) error { 8495 if v == nil { 8496 return fmt.Errorf("unexpected nil of type %T", v) 8497 } 8498 if value == nil { 8499 return nil 8500 } 8501 8502 shape, ok := value.(map[string]interface{}) 8503 if !ok { 8504 return fmt.Errorf("unexpected JSON type %v", value) 8505 } 8506 8507 var sv *types.CloudTrailConfigurationResult 8508 if *v == nil { 8509 sv = &types.CloudTrailConfigurationResult{} 8510 } else { 8511 sv = *v 8512 } 8513 8514 for key, value := range shape { 8515 switch key { 8516 case "status": 8517 if value != nil { 8518 jtv, ok := value.(string) 8519 if !ok { 8520 return fmt.Errorf("expected DataSourceStatus to be of type string, got %T instead", value) 8521 } 8522 sv.Status = types.DataSourceStatus(jtv) 8523 } 8524 8525 default: 8526 _, _ = key, value 8527 8528 } 8529 } 8530 *v = sv 8531 return nil 8532} 8533 8534func awsRestjson1_deserializeDocumentCondition(v **types.Condition, value interface{}) error { 8535 if v == nil { 8536 return fmt.Errorf("unexpected nil of type %T", v) 8537 } 8538 if value == nil { 8539 return nil 8540 } 8541 8542 shape, ok := value.(map[string]interface{}) 8543 if !ok { 8544 return fmt.Errorf("unexpected JSON type %v", value) 8545 } 8546 8547 var sv *types.Condition 8548 if *v == nil { 8549 sv = &types.Condition{} 8550 } else { 8551 sv = *v 8552 } 8553 8554 for key, value := range shape { 8555 switch key { 8556 case "eq": 8557 if err := awsRestjson1_deserializeDocumentEq(&sv.Eq, value); err != nil { 8558 return err 8559 } 8560 8561 case "equals": 8562 if err := awsRestjson1_deserializeDocumentEquals(&sv.Equals, value); err != nil { 8563 return err 8564 } 8565 8566 case "greaterThan": 8567 if value != nil { 8568 jtv, ok := value.(json.Number) 8569 if !ok { 8570 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 8571 } 8572 i64, err := jtv.Int64() 8573 if err != nil { 8574 return err 8575 } 8576 sv.GreaterThan = i64 8577 } 8578 8579 case "greaterThanOrEqual": 8580 if value != nil { 8581 jtv, ok := value.(json.Number) 8582 if !ok { 8583 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 8584 } 8585 i64, err := jtv.Int64() 8586 if err != nil { 8587 return err 8588 } 8589 sv.GreaterThanOrEqual = i64 8590 } 8591 8592 case "gt": 8593 if value != nil { 8594 jtv, ok := value.(json.Number) 8595 if !ok { 8596 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8597 } 8598 i64, err := jtv.Int64() 8599 if err != nil { 8600 return err 8601 } 8602 sv.Gt = int32(i64) 8603 } 8604 8605 case "gte": 8606 if value != nil { 8607 jtv, ok := value.(json.Number) 8608 if !ok { 8609 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8610 } 8611 i64, err := jtv.Int64() 8612 if err != nil { 8613 return err 8614 } 8615 sv.Gte = int32(i64) 8616 } 8617 8618 case "lessThan": 8619 if value != nil { 8620 jtv, ok := value.(json.Number) 8621 if !ok { 8622 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 8623 } 8624 i64, err := jtv.Int64() 8625 if err != nil { 8626 return err 8627 } 8628 sv.LessThan = i64 8629 } 8630 8631 case "lessThanOrEqual": 8632 if value != nil { 8633 jtv, ok := value.(json.Number) 8634 if !ok { 8635 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 8636 } 8637 i64, err := jtv.Int64() 8638 if err != nil { 8639 return err 8640 } 8641 sv.LessThanOrEqual = i64 8642 } 8643 8644 case "lt": 8645 if value != nil { 8646 jtv, ok := value.(json.Number) 8647 if !ok { 8648 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8649 } 8650 i64, err := jtv.Int64() 8651 if err != nil { 8652 return err 8653 } 8654 sv.Lt = int32(i64) 8655 } 8656 8657 case "lte": 8658 if value != nil { 8659 jtv, ok := value.(json.Number) 8660 if !ok { 8661 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8662 } 8663 i64, err := jtv.Int64() 8664 if err != nil { 8665 return err 8666 } 8667 sv.Lte = int32(i64) 8668 } 8669 8670 case "neq": 8671 if err := awsRestjson1_deserializeDocumentNeq(&sv.Neq, value); err != nil { 8672 return err 8673 } 8674 8675 case "notEquals": 8676 if err := awsRestjson1_deserializeDocumentNotEquals(&sv.NotEquals, value); err != nil { 8677 return err 8678 } 8679 8680 default: 8681 _, _ = key, value 8682 8683 } 8684 } 8685 *v = sv 8686 return nil 8687} 8688 8689func awsRestjson1_deserializeDocumentCountBySeverity(v *map[string]int32, value interface{}) error { 8690 if v == nil { 8691 return fmt.Errorf("unexpected nil of type %T", v) 8692 } 8693 if value == nil { 8694 return nil 8695 } 8696 8697 shape, ok := value.(map[string]interface{}) 8698 if !ok { 8699 return fmt.Errorf("unexpected JSON type %v", value) 8700 } 8701 8702 var mv map[string]int32 8703 if *v == nil { 8704 mv = map[string]int32{} 8705 } else { 8706 mv = *v 8707 } 8708 8709 for key, value := range shape { 8710 var parsedVal int32 8711 if value != nil { 8712 jtv, ok := value.(json.Number) 8713 if !ok { 8714 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 8715 } 8716 i64, err := jtv.Int64() 8717 if err != nil { 8718 return err 8719 } 8720 parsedVal = int32(i64) 8721 } 8722 mv[key] = parsedVal 8723 8724 } 8725 *v = mv 8726 return nil 8727} 8728 8729func awsRestjson1_deserializeDocumentCountry(v **types.Country, value interface{}) error { 8730 if v == nil { 8731 return fmt.Errorf("unexpected nil of type %T", v) 8732 } 8733 if value == nil { 8734 return nil 8735 } 8736 8737 shape, ok := value.(map[string]interface{}) 8738 if !ok { 8739 return fmt.Errorf("unexpected JSON type %v", value) 8740 } 8741 8742 var sv *types.Country 8743 if *v == nil { 8744 sv = &types.Country{} 8745 } else { 8746 sv = *v 8747 } 8748 8749 for key, value := range shape { 8750 switch key { 8751 case "countryCode": 8752 if value != nil { 8753 jtv, ok := value.(string) 8754 if !ok { 8755 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8756 } 8757 sv.CountryCode = ptr.String(jtv) 8758 } 8759 8760 case "countryName": 8761 if value != nil { 8762 jtv, ok := value.(string) 8763 if !ok { 8764 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8765 } 8766 sv.CountryName = ptr.String(jtv) 8767 } 8768 8769 default: 8770 _, _ = key, value 8771 8772 } 8773 } 8774 *v = sv 8775 return nil 8776} 8777 8778func awsRestjson1_deserializeDocumentCriterion(v *map[string]types.Condition, value interface{}) error { 8779 if v == nil { 8780 return fmt.Errorf("unexpected nil of type %T", v) 8781 } 8782 if value == nil { 8783 return nil 8784 } 8785 8786 shape, ok := value.(map[string]interface{}) 8787 if !ok { 8788 return fmt.Errorf("unexpected JSON type %v", value) 8789 } 8790 8791 var mv map[string]types.Condition 8792 if *v == nil { 8793 mv = map[string]types.Condition{} 8794 } else { 8795 mv = *v 8796 } 8797 8798 for key, value := range shape { 8799 var parsedVal types.Condition 8800 mapVar := parsedVal 8801 destAddr := &mapVar 8802 if err := awsRestjson1_deserializeDocumentCondition(&destAddr, value); err != nil { 8803 return err 8804 } 8805 parsedVal = *destAddr 8806 mv[key] = parsedVal 8807 8808 } 8809 *v = mv 8810 return nil 8811} 8812 8813func awsRestjson1_deserializeDocumentDataSourceConfigurationsResult(v **types.DataSourceConfigurationsResult, value interface{}) error { 8814 if v == nil { 8815 return fmt.Errorf("unexpected nil of type %T", v) 8816 } 8817 if value == nil { 8818 return nil 8819 } 8820 8821 shape, ok := value.(map[string]interface{}) 8822 if !ok { 8823 return fmt.Errorf("unexpected JSON type %v", value) 8824 } 8825 8826 var sv *types.DataSourceConfigurationsResult 8827 if *v == nil { 8828 sv = &types.DataSourceConfigurationsResult{} 8829 } else { 8830 sv = *v 8831 } 8832 8833 for key, value := range shape { 8834 switch key { 8835 case "cloudTrail": 8836 if err := awsRestjson1_deserializeDocumentCloudTrailConfigurationResult(&sv.CloudTrail, value); err != nil { 8837 return err 8838 } 8839 8840 case "dnsLogs": 8841 if err := awsRestjson1_deserializeDocumentDNSLogsConfigurationResult(&sv.DNSLogs, value); err != nil { 8842 return err 8843 } 8844 8845 case "flowLogs": 8846 if err := awsRestjson1_deserializeDocumentFlowLogsConfigurationResult(&sv.FlowLogs, value); err != nil { 8847 return err 8848 } 8849 8850 case "s3Logs": 8851 if err := awsRestjson1_deserializeDocumentS3LogsConfigurationResult(&sv.S3Logs, value); err != nil { 8852 return err 8853 } 8854 8855 default: 8856 _, _ = key, value 8857 8858 } 8859 } 8860 *v = sv 8861 return nil 8862} 8863 8864func awsRestjson1_deserializeDocumentDefaultServerSideEncryption(v **types.DefaultServerSideEncryption, value interface{}) error { 8865 if v == nil { 8866 return fmt.Errorf("unexpected nil of type %T", v) 8867 } 8868 if value == nil { 8869 return nil 8870 } 8871 8872 shape, ok := value.(map[string]interface{}) 8873 if !ok { 8874 return fmt.Errorf("unexpected JSON type %v", value) 8875 } 8876 8877 var sv *types.DefaultServerSideEncryption 8878 if *v == nil { 8879 sv = &types.DefaultServerSideEncryption{} 8880 } else { 8881 sv = *v 8882 } 8883 8884 for key, value := range shape { 8885 switch key { 8886 case "encryptionType": 8887 if value != nil { 8888 jtv, ok := value.(string) 8889 if !ok { 8890 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8891 } 8892 sv.EncryptionType = ptr.String(jtv) 8893 } 8894 8895 case "kmsMasterKeyArn": 8896 if value != nil { 8897 jtv, ok := value.(string) 8898 if !ok { 8899 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8900 } 8901 sv.KmsMasterKeyArn = ptr.String(jtv) 8902 } 8903 8904 default: 8905 _, _ = key, value 8906 8907 } 8908 } 8909 *v = sv 8910 return nil 8911} 8912 8913func awsRestjson1_deserializeDocumentDestination(v **types.Destination, value interface{}) error { 8914 if v == nil { 8915 return fmt.Errorf("unexpected nil of type %T", v) 8916 } 8917 if value == nil { 8918 return nil 8919 } 8920 8921 shape, ok := value.(map[string]interface{}) 8922 if !ok { 8923 return fmt.Errorf("unexpected JSON type %v", value) 8924 } 8925 8926 var sv *types.Destination 8927 if *v == nil { 8928 sv = &types.Destination{} 8929 } else { 8930 sv = *v 8931 } 8932 8933 for key, value := range shape { 8934 switch key { 8935 case "destinationId": 8936 if value != nil { 8937 jtv, ok := value.(string) 8938 if !ok { 8939 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8940 } 8941 sv.DestinationId = ptr.String(jtv) 8942 } 8943 8944 case "destinationType": 8945 if value != nil { 8946 jtv, ok := value.(string) 8947 if !ok { 8948 return fmt.Errorf("expected DestinationType to be of type string, got %T instead", value) 8949 } 8950 sv.DestinationType = types.DestinationType(jtv) 8951 } 8952 8953 case "status": 8954 if value != nil { 8955 jtv, ok := value.(string) 8956 if !ok { 8957 return fmt.Errorf("expected PublishingStatus to be of type string, got %T instead", value) 8958 } 8959 sv.Status = types.PublishingStatus(jtv) 8960 } 8961 8962 default: 8963 _, _ = key, value 8964 8965 } 8966 } 8967 *v = sv 8968 return nil 8969} 8970 8971func awsRestjson1_deserializeDocumentDestinationProperties(v **types.DestinationProperties, value interface{}) error { 8972 if v == nil { 8973 return fmt.Errorf("unexpected nil of type %T", v) 8974 } 8975 if value == nil { 8976 return nil 8977 } 8978 8979 shape, ok := value.(map[string]interface{}) 8980 if !ok { 8981 return fmt.Errorf("unexpected JSON type %v", value) 8982 } 8983 8984 var sv *types.DestinationProperties 8985 if *v == nil { 8986 sv = &types.DestinationProperties{} 8987 } else { 8988 sv = *v 8989 } 8990 8991 for key, value := range shape { 8992 switch key { 8993 case "destinationArn": 8994 if value != nil { 8995 jtv, ok := value.(string) 8996 if !ok { 8997 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8998 } 8999 sv.DestinationArn = ptr.String(jtv) 9000 } 9001 9002 case "kmsKeyArn": 9003 if value != nil { 9004 jtv, ok := value.(string) 9005 if !ok { 9006 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9007 } 9008 sv.KmsKeyArn = ptr.String(jtv) 9009 } 9010 9011 default: 9012 _, _ = key, value 9013 9014 } 9015 } 9016 *v = sv 9017 return nil 9018} 9019 9020func awsRestjson1_deserializeDocumentDestinations(v *[]types.Destination, value interface{}) error { 9021 if v == nil { 9022 return fmt.Errorf("unexpected nil of type %T", v) 9023 } 9024 if value == nil { 9025 return nil 9026 } 9027 9028 shape, ok := value.([]interface{}) 9029 if !ok { 9030 return fmt.Errorf("unexpected JSON type %v", value) 9031 } 9032 9033 var cv []types.Destination 9034 if *v == nil { 9035 cv = []types.Destination{} 9036 } else { 9037 cv = *v 9038 } 9039 9040 for _, value := range shape { 9041 var col types.Destination 9042 destAddr := &col 9043 if err := awsRestjson1_deserializeDocumentDestination(&destAddr, value); err != nil { 9044 return err 9045 } 9046 col = *destAddr 9047 cv = append(cv, col) 9048 9049 } 9050 *v = cv 9051 return nil 9052} 9053 9054func awsRestjson1_deserializeDocumentDetectorIds(v *[]string, value interface{}) error { 9055 if v == nil { 9056 return fmt.Errorf("unexpected nil of type %T", v) 9057 } 9058 if value == nil { 9059 return nil 9060 } 9061 9062 shape, ok := value.([]interface{}) 9063 if !ok { 9064 return fmt.Errorf("unexpected JSON type %v", value) 9065 } 9066 9067 var cv []string 9068 if *v == nil { 9069 cv = []string{} 9070 } else { 9071 cv = *v 9072 } 9073 9074 for _, value := range shape { 9075 var col string 9076 if value != nil { 9077 jtv, ok := value.(string) 9078 if !ok { 9079 return fmt.Errorf("expected DetectorId to be of type string, got %T instead", value) 9080 } 9081 col = jtv 9082 } 9083 cv = append(cv, col) 9084 9085 } 9086 *v = cv 9087 return nil 9088} 9089 9090func awsRestjson1_deserializeDocumentDNSLogsConfigurationResult(v **types.DNSLogsConfigurationResult, value interface{}) error { 9091 if v == nil { 9092 return fmt.Errorf("unexpected nil of type %T", v) 9093 } 9094 if value == nil { 9095 return nil 9096 } 9097 9098 shape, ok := value.(map[string]interface{}) 9099 if !ok { 9100 return fmt.Errorf("unexpected JSON type %v", value) 9101 } 9102 9103 var sv *types.DNSLogsConfigurationResult 9104 if *v == nil { 9105 sv = &types.DNSLogsConfigurationResult{} 9106 } else { 9107 sv = *v 9108 } 9109 9110 for key, value := range shape { 9111 switch key { 9112 case "status": 9113 if value != nil { 9114 jtv, ok := value.(string) 9115 if !ok { 9116 return fmt.Errorf("expected DataSourceStatus to be of type string, got %T instead", value) 9117 } 9118 sv.Status = types.DataSourceStatus(jtv) 9119 } 9120 9121 default: 9122 _, _ = key, value 9123 9124 } 9125 } 9126 *v = sv 9127 return nil 9128} 9129 9130func awsRestjson1_deserializeDocumentDnsRequestAction(v **types.DnsRequestAction, value interface{}) error { 9131 if v == nil { 9132 return fmt.Errorf("unexpected nil of type %T", v) 9133 } 9134 if value == nil { 9135 return nil 9136 } 9137 9138 shape, ok := value.(map[string]interface{}) 9139 if !ok { 9140 return fmt.Errorf("unexpected JSON type %v", value) 9141 } 9142 9143 var sv *types.DnsRequestAction 9144 if *v == nil { 9145 sv = &types.DnsRequestAction{} 9146 } else { 9147 sv = *v 9148 } 9149 9150 for key, value := range shape { 9151 switch key { 9152 case "domain": 9153 if value != nil { 9154 jtv, ok := value.(string) 9155 if !ok { 9156 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9157 } 9158 sv.Domain = ptr.String(jtv) 9159 } 9160 9161 default: 9162 _, _ = key, value 9163 9164 } 9165 } 9166 *v = sv 9167 return nil 9168} 9169 9170func awsRestjson1_deserializeDocumentDomainDetails(v **types.DomainDetails, value interface{}) error { 9171 if v == nil { 9172 return fmt.Errorf("unexpected nil of type %T", v) 9173 } 9174 if value == nil { 9175 return nil 9176 } 9177 9178 shape, ok := value.(map[string]interface{}) 9179 if !ok { 9180 return fmt.Errorf("unexpected JSON type %v", value) 9181 } 9182 9183 var sv *types.DomainDetails 9184 if *v == nil { 9185 sv = &types.DomainDetails{} 9186 } else { 9187 sv = *v 9188 } 9189 9190 for key, value := range shape { 9191 switch key { 9192 case "domain": 9193 if value != nil { 9194 jtv, ok := value.(string) 9195 if !ok { 9196 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9197 } 9198 sv.Domain = ptr.String(jtv) 9199 } 9200 9201 default: 9202 _, _ = key, value 9203 9204 } 9205 } 9206 *v = sv 9207 return nil 9208} 9209 9210func awsRestjson1_deserializeDocumentEq(v *[]string, value interface{}) error { 9211 if v == nil { 9212 return fmt.Errorf("unexpected nil of type %T", v) 9213 } 9214 if value == nil { 9215 return nil 9216 } 9217 9218 shape, ok := value.([]interface{}) 9219 if !ok { 9220 return fmt.Errorf("unexpected JSON type %v", value) 9221 } 9222 9223 var cv []string 9224 if *v == nil { 9225 cv = []string{} 9226 } else { 9227 cv = *v 9228 } 9229 9230 for _, value := range shape { 9231 var col string 9232 if value != nil { 9233 jtv, ok := value.(string) 9234 if !ok { 9235 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9236 } 9237 col = jtv 9238 } 9239 cv = append(cv, col) 9240 9241 } 9242 *v = cv 9243 return nil 9244} 9245 9246func awsRestjson1_deserializeDocumentEquals(v *[]string, value interface{}) error { 9247 if v == nil { 9248 return fmt.Errorf("unexpected nil of type %T", v) 9249 } 9250 if value == nil { 9251 return nil 9252 } 9253 9254 shape, ok := value.([]interface{}) 9255 if !ok { 9256 return fmt.Errorf("unexpected JSON type %v", value) 9257 } 9258 9259 var cv []string 9260 if *v == nil { 9261 cv = []string{} 9262 } else { 9263 cv = *v 9264 } 9265 9266 for _, value := range shape { 9267 var col string 9268 if value != nil { 9269 jtv, ok := value.(string) 9270 if !ok { 9271 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9272 } 9273 col = jtv 9274 } 9275 cv = append(cv, col) 9276 9277 } 9278 *v = cv 9279 return nil 9280} 9281 9282func awsRestjson1_deserializeDocumentEvidence(v **types.Evidence, value interface{}) error { 9283 if v == nil { 9284 return fmt.Errorf("unexpected nil of type %T", v) 9285 } 9286 if value == nil { 9287 return nil 9288 } 9289 9290 shape, ok := value.(map[string]interface{}) 9291 if !ok { 9292 return fmt.Errorf("unexpected JSON type %v", value) 9293 } 9294 9295 var sv *types.Evidence 9296 if *v == nil { 9297 sv = &types.Evidence{} 9298 } else { 9299 sv = *v 9300 } 9301 9302 for key, value := range shape { 9303 switch key { 9304 case "threatIntelligenceDetails": 9305 if err := awsRestjson1_deserializeDocumentThreatIntelligenceDetails(&sv.ThreatIntelligenceDetails, value); err != nil { 9306 return err 9307 } 9308 9309 default: 9310 _, _ = key, value 9311 9312 } 9313 } 9314 *v = sv 9315 return nil 9316} 9317 9318func awsRestjson1_deserializeDocumentFilterNames(v *[]string, value interface{}) error { 9319 if v == nil { 9320 return fmt.Errorf("unexpected nil of type %T", v) 9321 } 9322 if value == nil { 9323 return nil 9324 } 9325 9326 shape, ok := value.([]interface{}) 9327 if !ok { 9328 return fmt.Errorf("unexpected JSON type %v", value) 9329 } 9330 9331 var cv []string 9332 if *v == nil { 9333 cv = []string{} 9334 } else { 9335 cv = *v 9336 } 9337 9338 for _, value := range shape { 9339 var col string 9340 if value != nil { 9341 jtv, ok := value.(string) 9342 if !ok { 9343 return fmt.Errorf("expected FilterName to be of type string, got %T instead", value) 9344 } 9345 col = jtv 9346 } 9347 cv = append(cv, col) 9348 9349 } 9350 *v = cv 9351 return nil 9352} 9353 9354func awsRestjson1_deserializeDocumentFinding(v **types.Finding, value interface{}) error { 9355 if v == nil { 9356 return fmt.Errorf("unexpected nil of type %T", v) 9357 } 9358 if value == nil { 9359 return nil 9360 } 9361 9362 shape, ok := value.(map[string]interface{}) 9363 if !ok { 9364 return fmt.Errorf("unexpected JSON type %v", value) 9365 } 9366 9367 var sv *types.Finding 9368 if *v == nil { 9369 sv = &types.Finding{} 9370 } else { 9371 sv = *v 9372 } 9373 9374 for key, value := range shape { 9375 switch key { 9376 case "accountId": 9377 if value != nil { 9378 jtv, ok := value.(string) 9379 if !ok { 9380 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9381 } 9382 sv.AccountId = ptr.String(jtv) 9383 } 9384 9385 case "arn": 9386 if value != nil { 9387 jtv, ok := value.(string) 9388 if !ok { 9389 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9390 } 9391 sv.Arn = ptr.String(jtv) 9392 } 9393 9394 case "confidence": 9395 if value != nil { 9396 jtv, ok := value.(json.Number) 9397 if !ok { 9398 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 9399 } 9400 f64, err := jtv.Float64() 9401 if err != nil { 9402 return err 9403 } 9404 sv.Confidence = f64 9405 } 9406 9407 case "createdAt": 9408 if value != nil { 9409 jtv, ok := value.(string) 9410 if !ok { 9411 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9412 } 9413 sv.CreatedAt = ptr.String(jtv) 9414 } 9415 9416 case "description": 9417 if value != nil { 9418 jtv, ok := value.(string) 9419 if !ok { 9420 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9421 } 9422 sv.Description = ptr.String(jtv) 9423 } 9424 9425 case "id": 9426 if value != nil { 9427 jtv, ok := value.(string) 9428 if !ok { 9429 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9430 } 9431 sv.Id = ptr.String(jtv) 9432 } 9433 9434 case "partition": 9435 if value != nil { 9436 jtv, ok := value.(string) 9437 if !ok { 9438 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9439 } 9440 sv.Partition = ptr.String(jtv) 9441 } 9442 9443 case "region": 9444 if value != nil { 9445 jtv, ok := value.(string) 9446 if !ok { 9447 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9448 } 9449 sv.Region = ptr.String(jtv) 9450 } 9451 9452 case "resource": 9453 if err := awsRestjson1_deserializeDocumentResource(&sv.Resource, value); err != nil { 9454 return err 9455 } 9456 9457 case "schemaVersion": 9458 if value != nil { 9459 jtv, ok := value.(string) 9460 if !ok { 9461 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9462 } 9463 sv.SchemaVersion = ptr.String(jtv) 9464 } 9465 9466 case "service": 9467 if err := awsRestjson1_deserializeDocumentService(&sv.Service, value); err != nil { 9468 return err 9469 } 9470 9471 case "severity": 9472 if value != nil { 9473 jtv, ok := value.(json.Number) 9474 if !ok { 9475 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 9476 } 9477 f64, err := jtv.Float64() 9478 if err != nil { 9479 return err 9480 } 9481 sv.Severity = f64 9482 } 9483 9484 case "title": 9485 if value != nil { 9486 jtv, ok := value.(string) 9487 if !ok { 9488 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9489 } 9490 sv.Title = ptr.String(jtv) 9491 } 9492 9493 case "type": 9494 if value != nil { 9495 jtv, ok := value.(string) 9496 if !ok { 9497 return fmt.Errorf("expected FindingType to be of type string, got %T instead", value) 9498 } 9499 sv.Type = ptr.String(jtv) 9500 } 9501 9502 case "updatedAt": 9503 if value != nil { 9504 jtv, ok := value.(string) 9505 if !ok { 9506 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9507 } 9508 sv.UpdatedAt = ptr.String(jtv) 9509 } 9510 9511 default: 9512 _, _ = key, value 9513 9514 } 9515 } 9516 *v = sv 9517 return nil 9518} 9519 9520func awsRestjson1_deserializeDocumentFindingCriteria(v **types.FindingCriteria, value interface{}) error { 9521 if v == nil { 9522 return fmt.Errorf("unexpected nil of type %T", v) 9523 } 9524 if value == nil { 9525 return nil 9526 } 9527 9528 shape, ok := value.(map[string]interface{}) 9529 if !ok { 9530 return fmt.Errorf("unexpected JSON type %v", value) 9531 } 9532 9533 var sv *types.FindingCriteria 9534 if *v == nil { 9535 sv = &types.FindingCriteria{} 9536 } else { 9537 sv = *v 9538 } 9539 9540 for key, value := range shape { 9541 switch key { 9542 case "criterion": 9543 if err := awsRestjson1_deserializeDocumentCriterion(&sv.Criterion, value); err != nil { 9544 return err 9545 } 9546 9547 default: 9548 _, _ = key, value 9549 9550 } 9551 } 9552 *v = sv 9553 return nil 9554} 9555 9556func awsRestjson1_deserializeDocumentFindingIds(v *[]string, value interface{}) error { 9557 if v == nil { 9558 return fmt.Errorf("unexpected nil of type %T", v) 9559 } 9560 if value == nil { 9561 return nil 9562 } 9563 9564 shape, ok := value.([]interface{}) 9565 if !ok { 9566 return fmt.Errorf("unexpected JSON type %v", value) 9567 } 9568 9569 var cv []string 9570 if *v == nil { 9571 cv = []string{} 9572 } else { 9573 cv = *v 9574 } 9575 9576 for _, value := range shape { 9577 var col string 9578 if value != nil { 9579 jtv, ok := value.(string) 9580 if !ok { 9581 return fmt.Errorf("expected FindingId to be of type string, got %T instead", value) 9582 } 9583 col = jtv 9584 } 9585 cv = append(cv, col) 9586 9587 } 9588 *v = cv 9589 return nil 9590} 9591 9592func awsRestjson1_deserializeDocumentFindings(v *[]types.Finding, value interface{}) error { 9593 if v == nil { 9594 return fmt.Errorf("unexpected nil of type %T", v) 9595 } 9596 if value == nil { 9597 return nil 9598 } 9599 9600 shape, ok := value.([]interface{}) 9601 if !ok { 9602 return fmt.Errorf("unexpected JSON type %v", value) 9603 } 9604 9605 var cv []types.Finding 9606 if *v == nil { 9607 cv = []types.Finding{} 9608 } else { 9609 cv = *v 9610 } 9611 9612 for _, value := range shape { 9613 var col types.Finding 9614 destAddr := &col 9615 if err := awsRestjson1_deserializeDocumentFinding(&destAddr, value); err != nil { 9616 return err 9617 } 9618 col = *destAddr 9619 cv = append(cv, col) 9620 9621 } 9622 *v = cv 9623 return nil 9624} 9625 9626func awsRestjson1_deserializeDocumentFindingStatistics(v **types.FindingStatistics, value interface{}) error { 9627 if v == nil { 9628 return fmt.Errorf("unexpected nil of type %T", v) 9629 } 9630 if value == nil { 9631 return nil 9632 } 9633 9634 shape, ok := value.(map[string]interface{}) 9635 if !ok { 9636 return fmt.Errorf("unexpected JSON type %v", value) 9637 } 9638 9639 var sv *types.FindingStatistics 9640 if *v == nil { 9641 sv = &types.FindingStatistics{} 9642 } else { 9643 sv = *v 9644 } 9645 9646 for key, value := range shape { 9647 switch key { 9648 case "countBySeverity": 9649 if err := awsRestjson1_deserializeDocumentCountBySeverity(&sv.CountBySeverity, value); err != nil { 9650 return err 9651 } 9652 9653 default: 9654 _, _ = key, value 9655 9656 } 9657 } 9658 *v = sv 9659 return nil 9660} 9661 9662func awsRestjson1_deserializeDocumentFlowLogsConfigurationResult(v **types.FlowLogsConfigurationResult, value interface{}) error { 9663 if v == nil { 9664 return fmt.Errorf("unexpected nil of type %T", v) 9665 } 9666 if value == nil { 9667 return nil 9668 } 9669 9670 shape, ok := value.(map[string]interface{}) 9671 if !ok { 9672 return fmt.Errorf("unexpected JSON type %v", value) 9673 } 9674 9675 var sv *types.FlowLogsConfigurationResult 9676 if *v == nil { 9677 sv = &types.FlowLogsConfigurationResult{} 9678 } else { 9679 sv = *v 9680 } 9681 9682 for key, value := range shape { 9683 switch key { 9684 case "status": 9685 if value != nil { 9686 jtv, ok := value.(string) 9687 if !ok { 9688 return fmt.Errorf("expected DataSourceStatus to be of type string, got %T instead", value) 9689 } 9690 sv.Status = types.DataSourceStatus(jtv) 9691 } 9692 9693 default: 9694 _, _ = key, value 9695 9696 } 9697 } 9698 *v = sv 9699 return nil 9700} 9701 9702func awsRestjson1_deserializeDocumentGeoLocation(v **types.GeoLocation, value interface{}) error { 9703 if v == nil { 9704 return fmt.Errorf("unexpected nil of type %T", v) 9705 } 9706 if value == nil { 9707 return nil 9708 } 9709 9710 shape, ok := value.(map[string]interface{}) 9711 if !ok { 9712 return fmt.Errorf("unexpected JSON type %v", value) 9713 } 9714 9715 var sv *types.GeoLocation 9716 if *v == nil { 9717 sv = &types.GeoLocation{} 9718 } else { 9719 sv = *v 9720 } 9721 9722 for key, value := range shape { 9723 switch key { 9724 case "lat": 9725 if value != nil { 9726 jtv, ok := value.(json.Number) 9727 if !ok { 9728 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 9729 } 9730 f64, err := jtv.Float64() 9731 if err != nil { 9732 return err 9733 } 9734 sv.Lat = f64 9735 } 9736 9737 case "lon": 9738 if value != nil { 9739 jtv, ok := value.(json.Number) 9740 if !ok { 9741 return fmt.Errorf("expected Double to be json.Number, got %T instead", value) 9742 } 9743 f64, err := jtv.Float64() 9744 if err != nil { 9745 return err 9746 } 9747 sv.Lon = f64 9748 } 9749 9750 default: 9751 _, _ = key, value 9752 9753 } 9754 } 9755 *v = sv 9756 return nil 9757} 9758 9759func awsRestjson1_deserializeDocumentIamInstanceProfile(v **types.IamInstanceProfile, value interface{}) error { 9760 if v == nil { 9761 return fmt.Errorf("unexpected nil of type %T", v) 9762 } 9763 if value == nil { 9764 return nil 9765 } 9766 9767 shape, ok := value.(map[string]interface{}) 9768 if !ok { 9769 return fmt.Errorf("unexpected JSON type %v", value) 9770 } 9771 9772 var sv *types.IamInstanceProfile 9773 if *v == nil { 9774 sv = &types.IamInstanceProfile{} 9775 } else { 9776 sv = *v 9777 } 9778 9779 for key, value := range shape { 9780 switch key { 9781 case "arn": 9782 if value != nil { 9783 jtv, ok := value.(string) 9784 if !ok { 9785 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9786 } 9787 sv.Arn = ptr.String(jtv) 9788 } 9789 9790 case "id": 9791 if value != nil { 9792 jtv, ok := value.(string) 9793 if !ok { 9794 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9795 } 9796 sv.Id = ptr.String(jtv) 9797 } 9798 9799 default: 9800 _, _ = key, value 9801 9802 } 9803 } 9804 *v = sv 9805 return nil 9806} 9807 9808func awsRestjson1_deserializeDocumentInstanceDetails(v **types.InstanceDetails, value interface{}) error { 9809 if v == nil { 9810 return fmt.Errorf("unexpected nil of type %T", v) 9811 } 9812 if value == nil { 9813 return nil 9814 } 9815 9816 shape, ok := value.(map[string]interface{}) 9817 if !ok { 9818 return fmt.Errorf("unexpected JSON type %v", value) 9819 } 9820 9821 var sv *types.InstanceDetails 9822 if *v == nil { 9823 sv = &types.InstanceDetails{} 9824 } else { 9825 sv = *v 9826 } 9827 9828 for key, value := range shape { 9829 switch key { 9830 case "availabilityZone": 9831 if value != nil { 9832 jtv, ok := value.(string) 9833 if !ok { 9834 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9835 } 9836 sv.AvailabilityZone = ptr.String(jtv) 9837 } 9838 9839 case "iamInstanceProfile": 9840 if err := awsRestjson1_deserializeDocumentIamInstanceProfile(&sv.IamInstanceProfile, value); err != nil { 9841 return err 9842 } 9843 9844 case "imageDescription": 9845 if value != nil { 9846 jtv, ok := value.(string) 9847 if !ok { 9848 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9849 } 9850 sv.ImageDescription = ptr.String(jtv) 9851 } 9852 9853 case "imageId": 9854 if value != nil { 9855 jtv, ok := value.(string) 9856 if !ok { 9857 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9858 } 9859 sv.ImageId = ptr.String(jtv) 9860 } 9861 9862 case "instanceId": 9863 if value != nil { 9864 jtv, ok := value.(string) 9865 if !ok { 9866 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9867 } 9868 sv.InstanceId = ptr.String(jtv) 9869 } 9870 9871 case "instanceState": 9872 if value != nil { 9873 jtv, ok := value.(string) 9874 if !ok { 9875 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9876 } 9877 sv.InstanceState = ptr.String(jtv) 9878 } 9879 9880 case "instanceType": 9881 if value != nil { 9882 jtv, ok := value.(string) 9883 if !ok { 9884 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9885 } 9886 sv.InstanceType = ptr.String(jtv) 9887 } 9888 9889 case "launchTime": 9890 if value != nil { 9891 jtv, ok := value.(string) 9892 if !ok { 9893 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9894 } 9895 sv.LaunchTime = ptr.String(jtv) 9896 } 9897 9898 case "networkInterfaces": 9899 if err := awsRestjson1_deserializeDocumentNetworkInterfaces(&sv.NetworkInterfaces, value); err != nil { 9900 return err 9901 } 9902 9903 case "outpostArn": 9904 if value != nil { 9905 jtv, ok := value.(string) 9906 if !ok { 9907 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9908 } 9909 sv.OutpostArn = ptr.String(jtv) 9910 } 9911 9912 case "platform": 9913 if value != nil { 9914 jtv, ok := value.(string) 9915 if !ok { 9916 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9917 } 9918 sv.Platform = ptr.String(jtv) 9919 } 9920 9921 case "productCodes": 9922 if err := awsRestjson1_deserializeDocumentProductCodes(&sv.ProductCodes, value); err != nil { 9923 return err 9924 } 9925 9926 case "tags": 9927 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 9928 return err 9929 } 9930 9931 default: 9932 _, _ = key, value 9933 9934 } 9935 } 9936 *v = sv 9937 return nil 9938} 9939 9940func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 9941 if v == nil { 9942 return fmt.Errorf("unexpected nil of type %T", v) 9943 } 9944 if value == nil { 9945 return nil 9946 } 9947 9948 shape, ok := value.(map[string]interface{}) 9949 if !ok { 9950 return fmt.Errorf("unexpected JSON type %v", value) 9951 } 9952 9953 var sv *types.InternalServerErrorException 9954 if *v == nil { 9955 sv = &types.InternalServerErrorException{} 9956 } else { 9957 sv = *v 9958 } 9959 9960 for key, value := range shape { 9961 switch key { 9962 case "message": 9963 if value != nil { 9964 jtv, ok := value.(string) 9965 if !ok { 9966 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9967 } 9968 sv.Message = ptr.String(jtv) 9969 } 9970 9971 case "__type": 9972 if value != nil { 9973 jtv, ok := value.(string) 9974 if !ok { 9975 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9976 } 9977 sv.Type = ptr.String(jtv) 9978 } 9979 9980 default: 9981 _, _ = key, value 9982 9983 } 9984 } 9985 *v = sv 9986 return nil 9987} 9988 9989func awsRestjson1_deserializeDocumentInvitation(v **types.Invitation, value interface{}) error { 9990 if v == nil { 9991 return fmt.Errorf("unexpected nil of type %T", v) 9992 } 9993 if value == nil { 9994 return nil 9995 } 9996 9997 shape, ok := value.(map[string]interface{}) 9998 if !ok { 9999 return fmt.Errorf("unexpected JSON type %v", value) 10000 } 10001 10002 var sv *types.Invitation 10003 if *v == nil { 10004 sv = &types.Invitation{} 10005 } else { 10006 sv = *v 10007 } 10008 10009 for key, value := range shape { 10010 switch key { 10011 case "accountId": 10012 if value != nil { 10013 jtv, ok := value.(string) 10014 if !ok { 10015 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10016 } 10017 sv.AccountId = ptr.String(jtv) 10018 } 10019 10020 case "invitationId": 10021 if value != nil { 10022 jtv, ok := value.(string) 10023 if !ok { 10024 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10025 } 10026 sv.InvitationId = ptr.String(jtv) 10027 } 10028 10029 case "invitedAt": 10030 if value != nil { 10031 jtv, ok := value.(string) 10032 if !ok { 10033 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10034 } 10035 sv.InvitedAt = ptr.String(jtv) 10036 } 10037 10038 case "relationshipStatus": 10039 if value != nil { 10040 jtv, ok := value.(string) 10041 if !ok { 10042 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10043 } 10044 sv.RelationshipStatus = ptr.String(jtv) 10045 } 10046 10047 default: 10048 _, _ = key, value 10049 10050 } 10051 } 10052 *v = sv 10053 return nil 10054} 10055 10056func awsRestjson1_deserializeDocumentInvitations(v *[]types.Invitation, value interface{}) error { 10057 if v == nil { 10058 return fmt.Errorf("unexpected nil of type %T", v) 10059 } 10060 if value == nil { 10061 return nil 10062 } 10063 10064 shape, ok := value.([]interface{}) 10065 if !ok { 10066 return fmt.Errorf("unexpected JSON type %v", value) 10067 } 10068 10069 var cv []types.Invitation 10070 if *v == nil { 10071 cv = []types.Invitation{} 10072 } else { 10073 cv = *v 10074 } 10075 10076 for _, value := range shape { 10077 var col types.Invitation 10078 destAddr := &col 10079 if err := awsRestjson1_deserializeDocumentInvitation(&destAddr, value); err != nil { 10080 return err 10081 } 10082 col = *destAddr 10083 cv = append(cv, col) 10084 10085 } 10086 *v = cv 10087 return nil 10088} 10089 10090func awsRestjson1_deserializeDocumentIpSetIds(v *[]string, value interface{}) error { 10091 if v == nil { 10092 return fmt.Errorf("unexpected nil of type %T", v) 10093 } 10094 if value == nil { 10095 return nil 10096 } 10097 10098 shape, ok := value.([]interface{}) 10099 if !ok { 10100 return fmt.Errorf("unexpected JSON type %v", value) 10101 } 10102 10103 var cv []string 10104 if *v == nil { 10105 cv = []string{} 10106 } else { 10107 cv = *v 10108 } 10109 10110 for _, value := range shape { 10111 var col string 10112 if value != nil { 10113 jtv, ok := value.(string) 10114 if !ok { 10115 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10116 } 10117 col = jtv 10118 } 10119 cv = append(cv, col) 10120 10121 } 10122 *v = cv 10123 return nil 10124} 10125 10126func awsRestjson1_deserializeDocumentIpv6Addresses(v *[]string, value interface{}) error { 10127 if v == nil { 10128 return fmt.Errorf("unexpected nil of type %T", v) 10129 } 10130 if value == nil { 10131 return nil 10132 } 10133 10134 shape, ok := value.([]interface{}) 10135 if !ok { 10136 return fmt.Errorf("unexpected JSON type %v", value) 10137 } 10138 10139 var cv []string 10140 if *v == nil { 10141 cv = []string{} 10142 } else { 10143 cv = *v 10144 } 10145 10146 for _, value := range shape { 10147 var col string 10148 if value != nil { 10149 jtv, ok := value.(string) 10150 if !ok { 10151 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10152 } 10153 col = jtv 10154 } 10155 cv = append(cv, col) 10156 10157 } 10158 *v = cv 10159 return nil 10160} 10161 10162func awsRestjson1_deserializeDocumentLocalIpDetails(v **types.LocalIpDetails, value interface{}) error { 10163 if v == nil { 10164 return fmt.Errorf("unexpected nil of type %T", v) 10165 } 10166 if value == nil { 10167 return nil 10168 } 10169 10170 shape, ok := value.(map[string]interface{}) 10171 if !ok { 10172 return fmt.Errorf("unexpected JSON type %v", value) 10173 } 10174 10175 var sv *types.LocalIpDetails 10176 if *v == nil { 10177 sv = &types.LocalIpDetails{} 10178 } else { 10179 sv = *v 10180 } 10181 10182 for key, value := range shape { 10183 switch key { 10184 case "ipAddressV4": 10185 if value != nil { 10186 jtv, ok := value.(string) 10187 if !ok { 10188 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10189 } 10190 sv.IpAddressV4 = ptr.String(jtv) 10191 } 10192 10193 default: 10194 _, _ = key, value 10195 10196 } 10197 } 10198 *v = sv 10199 return nil 10200} 10201 10202func awsRestjson1_deserializeDocumentLocalPortDetails(v **types.LocalPortDetails, value interface{}) error { 10203 if v == nil { 10204 return fmt.Errorf("unexpected nil of type %T", v) 10205 } 10206 if value == nil { 10207 return nil 10208 } 10209 10210 shape, ok := value.(map[string]interface{}) 10211 if !ok { 10212 return fmt.Errorf("unexpected JSON type %v", value) 10213 } 10214 10215 var sv *types.LocalPortDetails 10216 if *v == nil { 10217 sv = &types.LocalPortDetails{} 10218 } else { 10219 sv = *v 10220 } 10221 10222 for key, value := range shape { 10223 switch key { 10224 case "port": 10225 if value != nil { 10226 jtv, ok := value.(json.Number) 10227 if !ok { 10228 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 10229 } 10230 i64, err := jtv.Int64() 10231 if err != nil { 10232 return err 10233 } 10234 sv.Port = int32(i64) 10235 } 10236 10237 case "portName": 10238 if value != nil { 10239 jtv, ok := value.(string) 10240 if !ok { 10241 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10242 } 10243 sv.PortName = ptr.String(jtv) 10244 } 10245 10246 default: 10247 _, _ = key, value 10248 10249 } 10250 } 10251 *v = sv 10252 return nil 10253} 10254 10255func awsRestjson1_deserializeDocumentMaster(v **types.Master, value interface{}) error { 10256 if v == nil { 10257 return fmt.Errorf("unexpected nil of type %T", v) 10258 } 10259 if value == nil { 10260 return nil 10261 } 10262 10263 shape, ok := value.(map[string]interface{}) 10264 if !ok { 10265 return fmt.Errorf("unexpected JSON type %v", value) 10266 } 10267 10268 var sv *types.Master 10269 if *v == nil { 10270 sv = &types.Master{} 10271 } else { 10272 sv = *v 10273 } 10274 10275 for key, value := range shape { 10276 switch key { 10277 case "accountId": 10278 if value != nil { 10279 jtv, ok := value.(string) 10280 if !ok { 10281 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10282 } 10283 sv.AccountId = ptr.String(jtv) 10284 } 10285 10286 case "invitationId": 10287 if value != nil { 10288 jtv, ok := value.(string) 10289 if !ok { 10290 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10291 } 10292 sv.InvitationId = ptr.String(jtv) 10293 } 10294 10295 case "invitedAt": 10296 if value != nil { 10297 jtv, ok := value.(string) 10298 if !ok { 10299 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10300 } 10301 sv.InvitedAt = ptr.String(jtv) 10302 } 10303 10304 case "relationshipStatus": 10305 if value != nil { 10306 jtv, ok := value.(string) 10307 if !ok { 10308 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10309 } 10310 sv.RelationshipStatus = ptr.String(jtv) 10311 } 10312 10313 default: 10314 _, _ = key, value 10315 10316 } 10317 } 10318 *v = sv 10319 return nil 10320} 10321 10322func awsRestjson1_deserializeDocumentMember(v **types.Member, value interface{}) error { 10323 if v == nil { 10324 return fmt.Errorf("unexpected nil of type %T", v) 10325 } 10326 if value == nil { 10327 return nil 10328 } 10329 10330 shape, ok := value.(map[string]interface{}) 10331 if !ok { 10332 return fmt.Errorf("unexpected JSON type %v", value) 10333 } 10334 10335 var sv *types.Member 10336 if *v == nil { 10337 sv = &types.Member{} 10338 } else { 10339 sv = *v 10340 } 10341 10342 for key, value := range shape { 10343 switch key { 10344 case "accountId": 10345 if value != nil { 10346 jtv, ok := value.(string) 10347 if !ok { 10348 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10349 } 10350 sv.AccountId = ptr.String(jtv) 10351 } 10352 10353 case "detectorId": 10354 if value != nil { 10355 jtv, ok := value.(string) 10356 if !ok { 10357 return fmt.Errorf("expected DetectorId to be of type string, got %T instead", value) 10358 } 10359 sv.DetectorId = ptr.String(jtv) 10360 } 10361 10362 case "email": 10363 if value != nil { 10364 jtv, ok := value.(string) 10365 if !ok { 10366 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 10367 } 10368 sv.Email = ptr.String(jtv) 10369 } 10370 10371 case "invitedAt": 10372 if value != nil { 10373 jtv, ok := value.(string) 10374 if !ok { 10375 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10376 } 10377 sv.InvitedAt = ptr.String(jtv) 10378 } 10379 10380 case "masterId": 10381 if value != nil { 10382 jtv, ok := value.(string) 10383 if !ok { 10384 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10385 } 10386 sv.MasterId = ptr.String(jtv) 10387 } 10388 10389 case "relationshipStatus": 10390 if value != nil { 10391 jtv, ok := value.(string) 10392 if !ok { 10393 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10394 } 10395 sv.RelationshipStatus = ptr.String(jtv) 10396 } 10397 10398 case "updatedAt": 10399 if value != nil { 10400 jtv, ok := value.(string) 10401 if !ok { 10402 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10403 } 10404 sv.UpdatedAt = ptr.String(jtv) 10405 } 10406 10407 default: 10408 _, _ = key, value 10409 10410 } 10411 } 10412 *v = sv 10413 return nil 10414} 10415 10416func awsRestjson1_deserializeDocumentMemberDataSourceConfiguration(v **types.MemberDataSourceConfiguration, value interface{}) error { 10417 if v == nil { 10418 return fmt.Errorf("unexpected nil of type %T", v) 10419 } 10420 if value == nil { 10421 return nil 10422 } 10423 10424 shape, ok := value.(map[string]interface{}) 10425 if !ok { 10426 return fmt.Errorf("unexpected JSON type %v", value) 10427 } 10428 10429 var sv *types.MemberDataSourceConfiguration 10430 if *v == nil { 10431 sv = &types.MemberDataSourceConfiguration{} 10432 } else { 10433 sv = *v 10434 } 10435 10436 for key, value := range shape { 10437 switch key { 10438 case "accountId": 10439 if value != nil { 10440 jtv, ok := value.(string) 10441 if !ok { 10442 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10443 } 10444 sv.AccountId = ptr.String(jtv) 10445 } 10446 10447 case "dataSources": 10448 if err := awsRestjson1_deserializeDocumentDataSourceConfigurationsResult(&sv.DataSources, value); err != nil { 10449 return err 10450 } 10451 10452 default: 10453 _, _ = key, value 10454 10455 } 10456 } 10457 *v = sv 10458 return nil 10459} 10460 10461func awsRestjson1_deserializeDocumentMemberDataSourceConfigurations(v *[]types.MemberDataSourceConfiguration, value interface{}) error { 10462 if v == nil { 10463 return fmt.Errorf("unexpected nil of type %T", v) 10464 } 10465 if value == nil { 10466 return nil 10467 } 10468 10469 shape, ok := value.([]interface{}) 10470 if !ok { 10471 return fmt.Errorf("unexpected JSON type %v", value) 10472 } 10473 10474 var cv []types.MemberDataSourceConfiguration 10475 if *v == nil { 10476 cv = []types.MemberDataSourceConfiguration{} 10477 } else { 10478 cv = *v 10479 } 10480 10481 for _, value := range shape { 10482 var col types.MemberDataSourceConfiguration 10483 destAddr := &col 10484 if err := awsRestjson1_deserializeDocumentMemberDataSourceConfiguration(&destAddr, value); err != nil { 10485 return err 10486 } 10487 col = *destAddr 10488 cv = append(cv, col) 10489 10490 } 10491 *v = cv 10492 return nil 10493} 10494 10495func awsRestjson1_deserializeDocumentMembers(v *[]types.Member, value interface{}) error { 10496 if v == nil { 10497 return fmt.Errorf("unexpected nil of type %T", v) 10498 } 10499 if value == nil { 10500 return nil 10501 } 10502 10503 shape, ok := value.([]interface{}) 10504 if !ok { 10505 return fmt.Errorf("unexpected JSON type %v", value) 10506 } 10507 10508 var cv []types.Member 10509 if *v == nil { 10510 cv = []types.Member{} 10511 } else { 10512 cv = *v 10513 } 10514 10515 for _, value := range shape { 10516 var col types.Member 10517 destAddr := &col 10518 if err := awsRestjson1_deserializeDocumentMember(&destAddr, value); err != nil { 10519 return err 10520 } 10521 col = *destAddr 10522 cv = append(cv, col) 10523 10524 } 10525 *v = cv 10526 return nil 10527} 10528 10529func awsRestjson1_deserializeDocumentNeq(v *[]string, value interface{}) error { 10530 if v == nil { 10531 return fmt.Errorf("unexpected nil of type %T", v) 10532 } 10533 if value == nil { 10534 return nil 10535 } 10536 10537 shape, ok := value.([]interface{}) 10538 if !ok { 10539 return fmt.Errorf("unexpected JSON type %v", value) 10540 } 10541 10542 var cv []string 10543 if *v == nil { 10544 cv = []string{} 10545 } else { 10546 cv = *v 10547 } 10548 10549 for _, value := range shape { 10550 var col string 10551 if value != nil { 10552 jtv, ok := value.(string) 10553 if !ok { 10554 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10555 } 10556 col = jtv 10557 } 10558 cv = append(cv, col) 10559 10560 } 10561 *v = cv 10562 return nil 10563} 10564 10565func awsRestjson1_deserializeDocumentNetworkConnectionAction(v **types.NetworkConnectionAction, value interface{}) error { 10566 if v == nil { 10567 return fmt.Errorf("unexpected nil of type %T", v) 10568 } 10569 if value == nil { 10570 return nil 10571 } 10572 10573 shape, ok := value.(map[string]interface{}) 10574 if !ok { 10575 return fmt.Errorf("unexpected JSON type %v", value) 10576 } 10577 10578 var sv *types.NetworkConnectionAction 10579 if *v == nil { 10580 sv = &types.NetworkConnectionAction{} 10581 } else { 10582 sv = *v 10583 } 10584 10585 for key, value := range shape { 10586 switch key { 10587 case "blocked": 10588 if value != nil { 10589 jtv, ok := value.(bool) 10590 if !ok { 10591 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 10592 } 10593 sv.Blocked = jtv 10594 } 10595 10596 case "connectionDirection": 10597 if value != nil { 10598 jtv, ok := value.(string) 10599 if !ok { 10600 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10601 } 10602 sv.ConnectionDirection = ptr.String(jtv) 10603 } 10604 10605 case "localIpDetails": 10606 if err := awsRestjson1_deserializeDocumentLocalIpDetails(&sv.LocalIpDetails, value); err != nil { 10607 return err 10608 } 10609 10610 case "localPortDetails": 10611 if err := awsRestjson1_deserializeDocumentLocalPortDetails(&sv.LocalPortDetails, value); err != nil { 10612 return err 10613 } 10614 10615 case "protocol": 10616 if value != nil { 10617 jtv, ok := value.(string) 10618 if !ok { 10619 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10620 } 10621 sv.Protocol = ptr.String(jtv) 10622 } 10623 10624 case "remoteIpDetails": 10625 if err := awsRestjson1_deserializeDocumentRemoteIpDetails(&sv.RemoteIpDetails, value); err != nil { 10626 return err 10627 } 10628 10629 case "remotePortDetails": 10630 if err := awsRestjson1_deserializeDocumentRemotePortDetails(&sv.RemotePortDetails, value); err != nil { 10631 return err 10632 } 10633 10634 default: 10635 _, _ = key, value 10636 10637 } 10638 } 10639 *v = sv 10640 return nil 10641} 10642 10643func awsRestjson1_deserializeDocumentNetworkInterface(v **types.NetworkInterface, value interface{}) error { 10644 if v == nil { 10645 return fmt.Errorf("unexpected nil of type %T", v) 10646 } 10647 if value == nil { 10648 return nil 10649 } 10650 10651 shape, ok := value.(map[string]interface{}) 10652 if !ok { 10653 return fmt.Errorf("unexpected JSON type %v", value) 10654 } 10655 10656 var sv *types.NetworkInterface 10657 if *v == nil { 10658 sv = &types.NetworkInterface{} 10659 } else { 10660 sv = *v 10661 } 10662 10663 for key, value := range shape { 10664 switch key { 10665 case "ipv6Addresses": 10666 if err := awsRestjson1_deserializeDocumentIpv6Addresses(&sv.Ipv6Addresses, value); err != nil { 10667 return err 10668 } 10669 10670 case "networkInterfaceId": 10671 if value != nil { 10672 jtv, ok := value.(string) 10673 if !ok { 10674 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10675 } 10676 sv.NetworkInterfaceId = ptr.String(jtv) 10677 } 10678 10679 case "privateDnsName": 10680 if value != nil { 10681 jtv, ok := value.(string) 10682 if !ok { 10683 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10684 } 10685 sv.PrivateDnsName = ptr.String(jtv) 10686 } 10687 10688 case "privateIpAddress": 10689 if value != nil { 10690 jtv, ok := value.(string) 10691 if !ok { 10692 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10693 } 10694 sv.PrivateIpAddress = ptr.String(jtv) 10695 } 10696 10697 case "privateIpAddresses": 10698 if err := awsRestjson1_deserializeDocumentPrivateIpAddresses(&sv.PrivateIpAddresses, value); err != nil { 10699 return err 10700 } 10701 10702 case "publicDnsName": 10703 if value != nil { 10704 jtv, ok := value.(string) 10705 if !ok { 10706 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10707 } 10708 sv.PublicDnsName = ptr.String(jtv) 10709 } 10710 10711 case "publicIp": 10712 if value != nil { 10713 jtv, ok := value.(string) 10714 if !ok { 10715 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10716 } 10717 sv.PublicIp = ptr.String(jtv) 10718 } 10719 10720 case "securityGroups": 10721 if err := awsRestjson1_deserializeDocumentSecurityGroups(&sv.SecurityGroups, value); err != nil { 10722 return err 10723 } 10724 10725 case "subnetId": 10726 if value != nil { 10727 jtv, ok := value.(string) 10728 if !ok { 10729 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10730 } 10731 sv.SubnetId = ptr.String(jtv) 10732 } 10733 10734 case "vpcId": 10735 if value != nil { 10736 jtv, ok := value.(string) 10737 if !ok { 10738 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10739 } 10740 sv.VpcId = ptr.String(jtv) 10741 } 10742 10743 default: 10744 _, _ = key, value 10745 10746 } 10747 } 10748 *v = sv 10749 return nil 10750} 10751 10752func awsRestjson1_deserializeDocumentNetworkInterfaces(v *[]types.NetworkInterface, value interface{}) error { 10753 if v == nil { 10754 return fmt.Errorf("unexpected nil of type %T", v) 10755 } 10756 if value == nil { 10757 return nil 10758 } 10759 10760 shape, ok := value.([]interface{}) 10761 if !ok { 10762 return fmt.Errorf("unexpected JSON type %v", value) 10763 } 10764 10765 var cv []types.NetworkInterface 10766 if *v == nil { 10767 cv = []types.NetworkInterface{} 10768 } else { 10769 cv = *v 10770 } 10771 10772 for _, value := range shape { 10773 var col types.NetworkInterface 10774 destAddr := &col 10775 if err := awsRestjson1_deserializeDocumentNetworkInterface(&destAddr, value); err != nil { 10776 return err 10777 } 10778 col = *destAddr 10779 cv = append(cv, col) 10780 10781 } 10782 *v = cv 10783 return nil 10784} 10785 10786func awsRestjson1_deserializeDocumentNotEquals(v *[]string, value interface{}) error { 10787 if v == nil { 10788 return fmt.Errorf("unexpected nil of type %T", v) 10789 } 10790 if value == nil { 10791 return nil 10792 } 10793 10794 shape, ok := value.([]interface{}) 10795 if !ok { 10796 return fmt.Errorf("unexpected JSON type %v", value) 10797 } 10798 10799 var cv []string 10800 if *v == nil { 10801 cv = []string{} 10802 } else { 10803 cv = *v 10804 } 10805 10806 for _, value := range shape { 10807 var col string 10808 if value != nil { 10809 jtv, ok := value.(string) 10810 if !ok { 10811 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10812 } 10813 col = jtv 10814 } 10815 cv = append(cv, col) 10816 10817 } 10818 *v = cv 10819 return nil 10820} 10821 10822func awsRestjson1_deserializeDocumentOrganization(v **types.Organization, value interface{}) error { 10823 if v == nil { 10824 return fmt.Errorf("unexpected nil of type %T", v) 10825 } 10826 if value == nil { 10827 return nil 10828 } 10829 10830 shape, ok := value.(map[string]interface{}) 10831 if !ok { 10832 return fmt.Errorf("unexpected JSON type %v", value) 10833 } 10834 10835 var sv *types.Organization 10836 if *v == nil { 10837 sv = &types.Organization{} 10838 } else { 10839 sv = *v 10840 } 10841 10842 for key, value := range shape { 10843 switch key { 10844 case "asn": 10845 if value != nil { 10846 jtv, ok := value.(string) 10847 if !ok { 10848 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10849 } 10850 sv.Asn = ptr.String(jtv) 10851 } 10852 10853 case "asnOrg": 10854 if value != nil { 10855 jtv, ok := value.(string) 10856 if !ok { 10857 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10858 } 10859 sv.AsnOrg = ptr.String(jtv) 10860 } 10861 10862 case "isp": 10863 if value != nil { 10864 jtv, ok := value.(string) 10865 if !ok { 10866 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10867 } 10868 sv.Isp = ptr.String(jtv) 10869 } 10870 10871 case "org": 10872 if value != nil { 10873 jtv, ok := value.(string) 10874 if !ok { 10875 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10876 } 10877 sv.Org = ptr.String(jtv) 10878 } 10879 10880 default: 10881 _, _ = key, value 10882 10883 } 10884 } 10885 *v = sv 10886 return nil 10887} 10888 10889func awsRestjson1_deserializeDocumentOrganizationDataSourceConfigurationsResult(v **types.OrganizationDataSourceConfigurationsResult, value interface{}) error { 10890 if v == nil { 10891 return fmt.Errorf("unexpected nil of type %T", v) 10892 } 10893 if value == nil { 10894 return nil 10895 } 10896 10897 shape, ok := value.(map[string]interface{}) 10898 if !ok { 10899 return fmt.Errorf("unexpected JSON type %v", value) 10900 } 10901 10902 var sv *types.OrganizationDataSourceConfigurationsResult 10903 if *v == nil { 10904 sv = &types.OrganizationDataSourceConfigurationsResult{} 10905 } else { 10906 sv = *v 10907 } 10908 10909 for key, value := range shape { 10910 switch key { 10911 case "s3Logs": 10912 if err := awsRestjson1_deserializeDocumentOrganizationS3LogsConfigurationResult(&sv.S3Logs, value); err != nil { 10913 return err 10914 } 10915 10916 default: 10917 _, _ = key, value 10918 10919 } 10920 } 10921 *v = sv 10922 return nil 10923} 10924 10925func awsRestjson1_deserializeDocumentOrganizationS3LogsConfigurationResult(v **types.OrganizationS3LogsConfigurationResult, value interface{}) error { 10926 if v == nil { 10927 return fmt.Errorf("unexpected nil of type %T", v) 10928 } 10929 if value == nil { 10930 return nil 10931 } 10932 10933 shape, ok := value.(map[string]interface{}) 10934 if !ok { 10935 return fmt.Errorf("unexpected JSON type %v", value) 10936 } 10937 10938 var sv *types.OrganizationS3LogsConfigurationResult 10939 if *v == nil { 10940 sv = &types.OrganizationS3LogsConfigurationResult{} 10941 } else { 10942 sv = *v 10943 } 10944 10945 for key, value := range shape { 10946 switch key { 10947 case "autoEnable": 10948 if value != nil { 10949 jtv, ok := value.(bool) 10950 if !ok { 10951 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 10952 } 10953 sv.AutoEnable = jtv 10954 } 10955 10956 default: 10957 _, _ = key, value 10958 10959 } 10960 } 10961 *v = sv 10962 return nil 10963} 10964 10965func awsRestjson1_deserializeDocumentOwner(v **types.Owner, value interface{}) error { 10966 if v == nil { 10967 return fmt.Errorf("unexpected nil of type %T", v) 10968 } 10969 if value == nil { 10970 return nil 10971 } 10972 10973 shape, ok := value.(map[string]interface{}) 10974 if !ok { 10975 return fmt.Errorf("unexpected JSON type %v", value) 10976 } 10977 10978 var sv *types.Owner 10979 if *v == nil { 10980 sv = &types.Owner{} 10981 } else { 10982 sv = *v 10983 } 10984 10985 for key, value := range shape { 10986 switch key { 10987 case "id": 10988 if value != nil { 10989 jtv, ok := value.(string) 10990 if !ok { 10991 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10992 } 10993 sv.Id = ptr.String(jtv) 10994 } 10995 10996 default: 10997 _, _ = key, value 10998 10999 } 11000 } 11001 *v = sv 11002 return nil 11003} 11004 11005func awsRestjson1_deserializeDocumentPermissionConfiguration(v **types.PermissionConfiguration, value interface{}) error { 11006 if v == nil { 11007 return fmt.Errorf("unexpected nil of type %T", v) 11008 } 11009 if value == nil { 11010 return nil 11011 } 11012 11013 shape, ok := value.(map[string]interface{}) 11014 if !ok { 11015 return fmt.Errorf("unexpected JSON type %v", value) 11016 } 11017 11018 var sv *types.PermissionConfiguration 11019 if *v == nil { 11020 sv = &types.PermissionConfiguration{} 11021 } else { 11022 sv = *v 11023 } 11024 11025 for key, value := range shape { 11026 switch key { 11027 case "accountLevelPermissions": 11028 if err := awsRestjson1_deserializeDocumentAccountLevelPermissions(&sv.AccountLevelPermissions, value); err != nil { 11029 return err 11030 } 11031 11032 case "bucketLevelPermissions": 11033 if err := awsRestjson1_deserializeDocumentBucketLevelPermissions(&sv.BucketLevelPermissions, value); err != nil { 11034 return err 11035 } 11036 11037 default: 11038 _, _ = key, value 11039 11040 } 11041 } 11042 *v = sv 11043 return nil 11044} 11045 11046func awsRestjson1_deserializeDocumentPortProbeAction(v **types.PortProbeAction, value interface{}) error { 11047 if v == nil { 11048 return fmt.Errorf("unexpected nil of type %T", v) 11049 } 11050 if value == nil { 11051 return nil 11052 } 11053 11054 shape, ok := value.(map[string]interface{}) 11055 if !ok { 11056 return fmt.Errorf("unexpected JSON type %v", value) 11057 } 11058 11059 var sv *types.PortProbeAction 11060 if *v == nil { 11061 sv = &types.PortProbeAction{} 11062 } else { 11063 sv = *v 11064 } 11065 11066 for key, value := range shape { 11067 switch key { 11068 case "blocked": 11069 if value != nil { 11070 jtv, ok := value.(bool) 11071 if !ok { 11072 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11073 } 11074 sv.Blocked = jtv 11075 } 11076 11077 case "portProbeDetails": 11078 if err := awsRestjson1_deserializeDocumentPortProbeDetails(&sv.PortProbeDetails, value); err != nil { 11079 return err 11080 } 11081 11082 default: 11083 _, _ = key, value 11084 11085 } 11086 } 11087 *v = sv 11088 return nil 11089} 11090 11091func awsRestjson1_deserializeDocumentPortProbeDetail(v **types.PortProbeDetail, value interface{}) error { 11092 if v == nil { 11093 return fmt.Errorf("unexpected nil of type %T", v) 11094 } 11095 if value == nil { 11096 return nil 11097 } 11098 11099 shape, ok := value.(map[string]interface{}) 11100 if !ok { 11101 return fmt.Errorf("unexpected JSON type %v", value) 11102 } 11103 11104 var sv *types.PortProbeDetail 11105 if *v == nil { 11106 sv = &types.PortProbeDetail{} 11107 } else { 11108 sv = *v 11109 } 11110 11111 for key, value := range shape { 11112 switch key { 11113 case "localIpDetails": 11114 if err := awsRestjson1_deserializeDocumentLocalIpDetails(&sv.LocalIpDetails, value); err != nil { 11115 return err 11116 } 11117 11118 case "localPortDetails": 11119 if err := awsRestjson1_deserializeDocumentLocalPortDetails(&sv.LocalPortDetails, value); err != nil { 11120 return err 11121 } 11122 11123 case "remoteIpDetails": 11124 if err := awsRestjson1_deserializeDocumentRemoteIpDetails(&sv.RemoteIpDetails, value); err != nil { 11125 return err 11126 } 11127 11128 default: 11129 _, _ = key, value 11130 11131 } 11132 } 11133 *v = sv 11134 return nil 11135} 11136 11137func awsRestjson1_deserializeDocumentPortProbeDetails(v *[]types.PortProbeDetail, value interface{}) error { 11138 if v == nil { 11139 return fmt.Errorf("unexpected nil of type %T", v) 11140 } 11141 if value == nil { 11142 return nil 11143 } 11144 11145 shape, ok := value.([]interface{}) 11146 if !ok { 11147 return fmt.Errorf("unexpected JSON type %v", value) 11148 } 11149 11150 var cv []types.PortProbeDetail 11151 if *v == nil { 11152 cv = []types.PortProbeDetail{} 11153 } else { 11154 cv = *v 11155 } 11156 11157 for _, value := range shape { 11158 var col types.PortProbeDetail 11159 destAddr := &col 11160 if err := awsRestjson1_deserializeDocumentPortProbeDetail(&destAddr, value); err != nil { 11161 return err 11162 } 11163 col = *destAddr 11164 cv = append(cv, col) 11165 11166 } 11167 *v = cv 11168 return nil 11169} 11170 11171func awsRestjson1_deserializeDocumentPrivateIpAddressDetails(v **types.PrivateIpAddressDetails, value interface{}) error { 11172 if v == nil { 11173 return fmt.Errorf("unexpected nil of type %T", v) 11174 } 11175 if value == nil { 11176 return nil 11177 } 11178 11179 shape, ok := value.(map[string]interface{}) 11180 if !ok { 11181 return fmt.Errorf("unexpected JSON type %v", value) 11182 } 11183 11184 var sv *types.PrivateIpAddressDetails 11185 if *v == nil { 11186 sv = &types.PrivateIpAddressDetails{} 11187 } else { 11188 sv = *v 11189 } 11190 11191 for key, value := range shape { 11192 switch key { 11193 case "privateDnsName": 11194 if value != nil { 11195 jtv, ok := value.(string) 11196 if !ok { 11197 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11198 } 11199 sv.PrivateDnsName = ptr.String(jtv) 11200 } 11201 11202 case "privateIpAddress": 11203 if value != nil { 11204 jtv, ok := value.(string) 11205 if !ok { 11206 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11207 } 11208 sv.PrivateIpAddress = ptr.String(jtv) 11209 } 11210 11211 default: 11212 _, _ = key, value 11213 11214 } 11215 } 11216 *v = sv 11217 return nil 11218} 11219 11220func awsRestjson1_deserializeDocumentPrivateIpAddresses(v *[]types.PrivateIpAddressDetails, value interface{}) error { 11221 if v == nil { 11222 return fmt.Errorf("unexpected nil of type %T", v) 11223 } 11224 if value == nil { 11225 return nil 11226 } 11227 11228 shape, ok := value.([]interface{}) 11229 if !ok { 11230 return fmt.Errorf("unexpected JSON type %v", value) 11231 } 11232 11233 var cv []types.PrivateIpAddressDetails 11234 if *v == nil { 11235 cv = []types.PrivateIpAddressDetails{} 11236 } else { 11237 cv = *v 11238 } 11239 11240 for _, value := range shape { 11241 var col types.PrivateIpAddressDetails 11242 destAddr := &col 11243 if err := awsRestjson1_deserializeDocumentPrivateIpAddressDetails(&destAddr, value); err != nil { 11244 return err 11245 } 11246 col = *destAddr 11247 cv = append(cv, col) 11248 11249 } 11250 *v = cv 11251 return nil 11252} 11253 11254func awsRestjson1_deserializeDocumentProductCode(v **types.ProductCode, value interface{}) error { 11255 if v == nil { 11256 return fmt.Errorf("unexpected nil of type %T", v) 11257 } 11258 if value == nil { 11259 return nil 11260 } 11261 11262 shape, ok := value.(map[string]interface{}) 11263 if !ok { 11264 return fmt.Errorf("unexpected JSON type %v", value) 11265 } 11266 11267 var sv *types.ProductCode 11268 if *v == nil { 11269 sv = &types.ProductCode{} 11270 } else { 11271 sv = *v 11272 } 11273 11274 for key, value := range shape { 11275 switch key { 11276 case "code": 11277 if value != nil { 11278 jtv, ok := value.(string) 11279 if !ok { 11280 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11281 } 11282 sv.Code = ptr.String(jtv) 11283 } 11284 11285 case "productType": 11286 if value != nil { 11287 jtv, ok := value.(string) 11288 if !ok { 11289 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11290 } 11291 sv.ProductType = ptr.String(jtv) 11292 } 11293 11294 default: 11295 _, _ = key, value 11296 11297 } 11298 } 11299 *v = sv 11300 return nil 11301} 11302 11303func awsRestjson1_deserializeDocumentProductCodes(v *[]types.ProductCode, value interface{}) error { 11304 if v == nil { 11305 return fmt.Errorf("unexpected nil of type %T", v) 11306 } 11307 if value == nil { 11308 return nil 11309 } 11310 11311 shape, ok := value.([]interface{}) 11312 if !ok { 11313 return fmt.Errorf("unexpected JSON type %v", value) 11314 } 11315 11316 var cv []types.ProductCode 11317 if *v == nil { 11318 cv = []types.ProductCode{} 11319 } else { 11320 cv = *v 11321 } 11322 11323 for _, value := range shape { 11324 var col types.ProductCode 11325 destAddr := &col 11326 if err := awsRestjson1_deserializeDocumentProductCode(&destAddr, value); err != nil { 11327 return err 11328 } 11329 col = *destAddr 11330 cv = append(cv, col) 11331 11332 } 11333 *v = cv 11334 return nil 11335} 11336 11337func awsRestjson1_deserializeDocumentPublicAccess(v **types.PublicAccess, value interface{}) error { 11338 if v == nil { 11339 return fmt.Errorf("unexpected nil of type %T", v) 11340 } 11341 if value == nil { 11342 return nil 11343 } 11344 11345 shape, ok := value.(map[string]interface{}) 11346 if !ok { 11347 return fmt.Errorf("unexpected JSON type %v", value) 11348 } 11349 11350 var sv *types.PublicAccess 11351 if *v == nil { 11352 sv = &types.PublicAccess{} 11353 } else { 11354 sv = *v 11355 } 11356 11357 for key, value := range shape { 11358 switch key { 11359 case "effectivePermission": 11360 if value != nil { 11361 jtv, ok := value.(string) 11362 if !ok { 11363 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11364 } 11365 sv.EffectivePermission = ptr.String(jtv) 11366 } 11367 11368 case "permissionConfiguration": 11369 if err := awsRestjson1_deserializeDocumentPermissionConfiguration(&sv.PermissionConfiguration, value); err != nil { 11370 return err 11371 } 11372 11373 default: 11374 _, _ = key, value 11375 11376 } 11377 } 11378 *v = sv 11379 return nil 11380} 11381 11382func awsRestjson1_deserializeDocumentRemoteIpDetails(v **types.RemoteIpDetails, value interface{}) error { 11383 if v == nil { 11384 return fmt.Errorf("unexpected nil of type %T", v) 11385 } 11386 if value == nil { 11387 return nil 11388 } 11389 11390 shape, ok := value.(map[string]interface{}) 11391 if !ok { 11392 return fmt.Errorf("unexpected JSON type %v", value) 11393 } 11394 11395 var sv *types.RemoteIpDetails 11396 if *v == nil { 11397 sv = &types.RemoteIpDetails{} 11398 } else { 11399 sv = *v 11400 } 11401 11402 for key, value := range shape { 11403 switch key { 11404 case "city": 11405 if err := awsRestjson1_deserializeDocumentCity(&sv.City, value); err != nil { 11406 return err 11407 } 11408 11409 case "country": 11410 if err := awsRestjson1_deserializeDocumentCountry(&sv.Country, value); err != nil { 11411 return err 11412 } 11413 11414 case "geoLocation": 11415 if err := awsRestjson1_deserializeDocumentGeoLocation(&sv.GeoLocation, value); err != nil { 11416 return err 11417 } 11418 11419 case "ipAddressV4": 11420 if value != nil { 11421 jtv, ok := value.(string) 11422 if !ok { 11423 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11424 } 11425 sv.IpAddressV4 = ptr.String(jtv) 11426 } 11427 11428 case "organization": 11429 if err := awsRestjson1_deserializeDocumentOrganization(&sv.Organization, value); err != nil { 11430 return err 11431 } 11432 11433 default: 11434 _, _ = key, value 11435 11436 } 11437 } 11438 *v = sv 11439 return nil 11440} 11441 11442func awsRestjson1_deserializeDocumentRemotePortDetails(v **types.RemotePortDetails, value interface{}) error { 11443 if v == nil { 11444 return fmt.Errorf("unexpected nil of type %T", v) 11445 } 11446 if value == nil { 11447 return nil 11448 } 11449 11450 shape, ok := value.(map[string]interface{}) 11451 if !ok { 11452 return fmt.Errorf("unexpected JSON type %v", value) 11453 } 11454 11455 var sv *types.RemotePortDetails 11456 if *v == nil { 11457 sv = &types.RemotePortDetails{} 11458 } else { 11459 sv = *v 11460 } 11461 11462 for key, value := range shape { 11463 switch key { 11464 case "port": 11465 if value != nil { 11466 jtv, ok := value.(json.Number) 11467 if !ok { 11468 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 11469 } 11470 i64, err := jtv.Int64() 11471 if err != nil { 11472 return err 11473 } 11474 sv.Port = int32(i64) 11475 } 11476 11477 case "portName": 11478 if value != nil { 11479 jtv, ok := value.(string) 11480 if !ok { 11481 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11482 } 11483 sv.PortName = ptr.String(jtv) 11484 } 11485 11486 default: 11487 _, _ = key, value 11488 11489 } 11490 } 11491 *v = sv 11492 return nil 11493} 11494 11495func awsRestjson1_deserializeDocumentResource(v **types.Resource, value interface{}) error { 11496 if v == nil { 11497 return fmt.Errorf("unexpected nil of type %T", v) 11498 } 11499 if value == nil { 11500 return nil 11501 } 11502 11503 shape, ok := value.(map[string]interface{}) 11504 if !ok { 11505 return fmt.Errorf("unexpected JSON type %v", value) 11506 } 11507 11508 var sv *types.Resource 11509 if *v == nil { 11510 sv = &types.Resource{} 11511 } else { 11512 sv = *v 11513 } 11514 11515 for key, value := range shape { 11516 switch key { 11517 case "accessKeyDetails": 11518 if err := awsRestjson1_deserializeDocumentAccessKeyDetails(&sv.AccessKeyDetails, value); err != nil { 11519 return err 11520 } 11521 11522 case "instanceDetails": 11523 if err := awsRestjson1_deserializeDocumentInstanceDetails(&sv.InstanceDetails, value); err != nil { 11524 return err 11525 } 11526 11527 case "resourceType": 11528 if value != nil { 11529 jtv, ok := value.(string) 11530 if !ok { 11531 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11532 } 11533 sv.ResourceType = ptr.String(jtv) 11534 } 11535 11536 case "s3BucketDetails": 11537 if err := awsRestjson1_deserializeDocumentS3BucketDetails(&sv.S3BucketDetails, value); err != nil { 11538 return err 11539 } 11540 11541 default: 11542 _, _ = key, value 11543 11544 } 11545 } 11546 *v = sv 11547 return nil 11548} 11549 11550func awsRestjson1_deserializeDocumentS3BucketDetail(v **types.S3BucketDetail, value interface{}) error { 11551 if v == nil { 11552 return fmt.Errorf("unexpected nil of type %T", v) 11553 } 11554 if value == nil { 11555 return nil 11556 } 11557 11558 shape, ok := value.(map[string]interface{}) 11559 if !ok { 11560 return fmt.Errorf("unexpected JSON type %v", value) 11561 } 11562 11563 var sv *types.S3BucketDetail 11564 if *v == nil { 11565 sv = &types.S3BucketDetail{} 11566 } else { 11567 sv = *v 11568 } 11569 11570 for key, value := range shape { 11571 switch key { 11572 case "arn": 11573 if value != nil { 11574 jtv, ok := value.(string) 11575 if !ok { 11576 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11577 } 11578 sv.Arn = ptr.String(jtv) 11579 } 11580 11581 case "createdAt": 11582 if value != nil { 11583 jtv, ok := value.(json.Number) 11584 if !ok { 11585 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 11586 } 11587 f64, err := jtv.Float64() 11588 if err != nil { 11589 return err 11590 } 11591 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11592 } 11593 11594 case "defaultServerSideEncryption": 11595 if err := awsRestjson1_deserializeDocumentDefaultServerSideEncryption(&sv.DefaultServerSideEncryption, value); err != nil { 11596 return err 11597 } 11598 11599 case "name": 11600 if value != nil { 11601 jtv, ok := value.(string) 11602 if !ok { 11603 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11604 } 11605 sv.Name = ptr.String(jtv) 11606 } 11607 11608 case "owner": 11609 if err := awsRestjson1_deserializeDocumentOwner(&sv.Owner, value); err != nil { 11610 return err 11611 } 11612 11613 case "publicAccess": 11614 if err := awsRestjson1_deserializeDocumentPublicAccess(&sv.PublicAccess, value); err != nil { 11615 return err 11616 } 11617 11618 case "tags": 11619 if err := awsRestjson1_deserializeDocumentTags(&sv.Tags, value); err != nil { 11620 return err 11621 } 11622 11623 case "type": 11624 if value != nil { 11625 jtv, ok := value.(string) 11626 if !ok { 11627 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11628 } 11629 sv.Type = ptr.String(jtv) 11630 } 11631 11632 default: 11633 _, _ = key, value 11634 11635 } 11636 } 11637 *v = sv 11638 return nil 11639} 11640 11641func awsRestjson1_deserializeDocumentS3BucketDetails(v *[]types.S3BucketDetail, value interface{}) error { 11642 if v == nil { 11643 return fmt.Errorf("unexpected nil of type %T", v) 11644 } 11645 if value == nil { 11646 return nil 11647 } 11648 11649 shape, ok := value.([]interface{}) 11650 if !ok { 11651 return fmt.Errorf("unexpected JSON type %v", value) 11652 } 11653 11654 var cv []types.S3BucketDetail 11655 if *v == nil { 11656 cv = []types.S3BucketDetail{} 11657 } else { 11658 cv = *v 11659 } 11660 11661 for _, value := range shape { 11662 var col types.S3BucketDetail 11663 destAddr := &col 11664 if err := awsRestjson1_deserializeDocumentS3BucketDetail(&destAddr, value); err != nil { 11665 return err 11666 } 11667 col = *destAddr 11668 cv = append(cv, col) 11669 11670 } 11671 *v = cv 11672 return nil 11673} 11674 11675func awsRestjson1_deserializeDocumentS3LogsConfigurationResult(v **types.S3LogsConfigurationResult, value interface{}) error { 11676 if v == nil { 11677 return fmt.Errorf("unexpected nil of type %T", v) 11678 } 11679 if value == nil { 11680 return nil 11681 } 11682 11683 shape, ok := value.(map[string]interface{}) 11684 if !ok { 11685 return fmt.Errorf("unexpected JSON type %v", value) 11686 } 11687 11688 var sv *types.S3LogsConfigurationResult 11689 if *v == nil { 11690 sv = &types.S3LogsConfigurationResult{} 11691 } else { 11692 sv = *v 11693 } 11694 11695 for key, value := range shape { 11696 switch key { 11697 case "status": 11698 if value != nil { 11699 jtv, ok := value.(string) 11700 if !ok { 11701 return fmt.Errorf("expected DataSourceStatus to be of type string, got %T instead", value) 11702 } 11703 sv.Status = types.DataSourceStatus(jtv) 11704 } 11705 11706 default: 11707 _, _ = key, value 11708 11709 } 11710 } 11711 *v = sv 11712 return nil 11713} 11714 11715func awsRestjson1_deserializeDocumentSecurityGroup(v **types.SecurityGroup, value interface{}) error { 11716 if v == nil { 11717 return fmt.Errorf("unexpected nil of type %T", v) 11718 } 11719 if value == nil { 11720 return nil 11721 } 11722 11723 shape, ok := value.(map[string]interface{}) 11724 if !ok { 11725 return fmt.Errorf("unexpected JSON type %v", value) 11726 } 11727 11728 var sv *types.SecurityGroup 11729 if *v == nil { 11730 sv = &types.SecurityGroup{} 11731 } else { 11732 sv = *v 11733 } 11734 11735 for key, value := range shape { 11736 switch key { 11737 case "groupId": 11738 if value != nil { 11739 jtv, ok := value.(string) 11740 if !ok { 11741 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11742 } 11743 sv.GroupId = ptr.String(jtv) 11744 } 11745 11746 case "groupName": 11747 if value != nil { 11748 jtv, ok := value.(string) 11749 if !ok { 11750 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11751 } 11752 sv.GroupName = ptr.String(jtv) 11753 } 11754 11755 default: 11756 _, _ = key, value 11757 11758 } 11759 } 11760 *v = sv 11761 return nil 11762} 11763 11764func awsRestjson1_deserializeDocumentSecurityGroups(v *[]types.SecurityGroup, value interface{}) error { 11765 if v == nil { 11766 return fmt.Errorf("unexpected nil of type %T", v) 11767 } 11768 if value == nil { 11769 return nil 11770 } 11771 11772 shape, ok := value.([]interface{}) 11773 if !ok { 11774 return fmt.Errorf("unexpected JSON type %v", value) 11775 } 11776 11777 var cv []types.SecurityGroup 11778 if *v == nil { 11779 cv = []types.SecurityGroup{} 11780 } else { 11781 cv = *v 11782 } 11783 11784 for _, value := range shape { 11785 var col types.SecurityGroup 11786 destAddr := &col 11787 if err := awsRestjson1_deserializeDocumentSecurityGroup(&destAddr, value); err != nil { 11788 return err 11789 } 11790 col = *destAddr 11791 cv = append(cv, col) 11792 11793 } 11794 *v = cv 11795 return nil 11796} 11797 11798func awsRestjson1_deserializeDocumentService(v **types.Service, value interface{}) error { 11799 if v == nil { 11800 return fmt.Errorf("unexpected nil of type %T", v) 11801 } 11802 if value == nil { 11803 return nil 11804 } 11805 11806 shape, ok := value.(map[string]interface{}) 11807 if !ok { 11808 return fmt.Errorf("unexpected JSON type %v", value) 11809 } 11810 11811 var sv *types.Service 11812 if *v == nil { 11813 sv = &types.Service{} 11814 } else { 11815 sv = *v 11816 } 11817 11818 for key, value := range shape { 11819 switch key { 11820 case "action": 11821 if err := awsRestjson1_deserializeDocumentAction(&sv.Action, value); err != nil { 11822 return err 11823 } 11824 11825 case "archived": 11826 if value != nil { 11827 jtv, ok := value.(bool) 11828 if !ok { 11829 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11830 } 11831 sv.Archived = jtv 11832 } 11833 11834 case "count": 11835 if value != nil { 11836 jtv, ok := value.(json.Number) 11837 if !ok { 11838 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 11839 } 11840 i64, err := jtv.Int64() 11841 if err != nil { 11842 return err 11843 } 11844 sv.Count = int32(i64) 11845 } 11846 11847 case "detectorId": 11848 if value != nil { 11849 jtv, ok := value.(string) 11850 if !ok { 11851 return fmt.Errorf("expected DetectorId to be of type string, got %T instead", value) 11852 } 11853 sv.DetectorId = ptr.String(jtv) 11854 } 11855 11856 case "eventFirstSeen": 11857 if value != nil { 11858 jtv, ok := value.(string) 11859 if !ok { 11860 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11861 } 11862 sv.EventFirstSeen = ptr.String(jtv) 11863 } 11864 11865 case "eventLastSeen": 11866 if value != nil { 11867 jtv, ok := value.(string) 11868 if !ok { 11869 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11870 } 11871 sv.EventLastSeen = ptr.String(jtv) 11872 } 11873 11874 case "evidence": 11875 if err := awsRestjson1_deserializeDocumentEvidence(&sv.Evidence, value); err != nil { 11876 return err 11877 } 11878 11879 case "resourceRole": 11880 if value != nil { 11881 jtv, ok := value.(string) 11882 if !ok { 11883 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11884 } 11885 sv.ResourceRole = ptr.String(jtv) 11886 } 11887 11888 case "serviceName": 11889 if value != nil { 11890 jtv, ok := value.(string) 11891 if !ok { 11892 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11893 } 11894 sv.ServiceName = ptr.String(jtv) 11895 } 11896 11897 case "userFeedback": 11898 if value != nil { 11899 jtv, ok := value.(string) 11900 if !ok { 11901 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11902 } 11903 sv.UserFeedback = ptr.String(jtv) 11904 } 11905 11906 default: 11907 _, _ = key, value 11908 11909 } 11910 } 11911 *v = sv 11912 return nil 11913} 11914 11915func awsRestjson1_deserializeDocumentTag(v **types.Tag, value interface{}) error { 11916 if v == nil { 11917 return fmt.Errorf("unexpected nil of type %T", v) 11918 } 11919 if value == nil { 11920 return nil 11921 } 11922 11923 shape, ok := value.(map[string]interface{}) 11924 if !ok { 11925 return fmt.Errorf("unexpected JSON type %v", value) 11926 } 11927 11928 var sv *types.Tag 11929 if *v == nil { 11930 sv = &types.Tag{} 11931 } else { 11932 sv = *v 11933 } 11934 11935 for key, value := range shape { 11936 switch key { 11937 case "key": 11938 if value != nil { 11939 jtv, ok := value.(string) 11940 if !ok { 11941 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11942 } 11943 sv.Key = ptr.String(jtv) 11944 } 11945 11946 case "value": 11947 if value != nil { 11948 jtv, ok := value.(string) 11949 if !ok { 11950 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11951 } 11952 sv.Value = ptr.String(jtv) 11953 } 11954 11955 default: 11956 _, _ = key, value 11957 11958 } 11959 } 11960 *v = sv 11961 return nil 11962} 11963 11964func awsRestjson1_deserializeDocumentTagMap(v *map[string]string, value interface{}) error { 11965 if v == nil { 11966 return fmt.Errorf("unexpected nil of type %T", v) 11967 } 11968 if value == nil { 11969 return nil 11970 } 11971 11972 shape, ok := value.(map[string]interface{}) 11973 if !ok { 11974 return fmt.Errorf("unexpected JSON type %v", value) 11975 } 11976 11977 var mv map[string]string 11978 if *v == nil { 11979 mv = map[string]string{} 11980 } else { 11981 mv = *v 11982 } 11983 11984 for key, value := range shape { 11985 var parsedVal string 11986 if value != nil { 11987 jtv, ok := value.(string) 11988 if !ok { 11989 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 11990 } 11991 parsedVal = jtv 11992 } 11993 mv[key] = parsedVal 11994 11995 } 11996 *v = mv 11997 return nil 11998} 11999 12000func awsRestjson1_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 12001 if v == nil { 12002 return fmt.Errorf("unexpected nil of type %T", v) 12003 } 12004 if value == nil { 12005 return nil 12006 } 12007 12008 shape, ok := value.([]interface{}) 12009 if !ok { 12010 return fmt.Errorf("unexpected JSON type %v", value) 12011 } 12012 12013 var cv []types.Tag 12014 if *v == nil { 12015 cv = []types.Tag{} 12016 } else { 12017 cv = *v 12018 } 12019 12020 for _, value := range shape { 12021 var col types.Tag 12022 destAddr := &col 12023 if err := awsRestjson1_deserializeDocumentTag(&destAddr, value); err != nil { 12024 return err 12025 } 12026 col = *destAddr 12027 cv = append(cv, col) 12028 12029 } 12030 *v = cv 12031 return nil 12032} 12033 12034func awsRestjson1_deserializeDocumentThreatIntelligenceDetail(v **types.ThreatIntelligenceDetail, value interface{}) error { 12035 if v == nil { 12036 return fmt.Errorf("unexpected nil of type %T", v) 12037 } 12038 if value == nil { 12039 return nil 12040 } 12041 12042 shape, ok := value.(map[string]interface{}) 12043 if !ok { 12044 return fmt.Errorf("unexpected JSON type %v", value) 12045 } 12046 12047 var sv *types.ThreatIntelligenceDetail 12048 if *v == nil { 12049 sv = &types.ThreatIntelligenceDetail{} 12050 } else { 12051 sv = *v 12052 } 12053 12054 for key, value := range shape { 12055 switch key { 12056 case "threatListName": 12057 if value != nil { 12058 jtv, ok := value.(string) 12059 if !ok { 12060 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12061 } 12062 sv.ThreatListName = ptr.String(jtv) 12063 } 12064 12065 case "threatNames": 12066 if err := awsRestjson1_deserializeDocumentThreatNames(&sv.ThreatNames, value); err != nil { 12067 return err 12068 } 12069 12070 default: 12071 _, _ = key, value 12072 12073 } 12074 } 12075 *v = sv 12076 return nil 12077} 12078 12079func awsRestjson1_deserializeDocumentThreatIntelligenceDetails(v *[]types.ThreatIntelligenceDetail, value interface{}) error { 12080 if v == nil { 12081 return fmt.Errorf("unexpected nil of type %T", v) 12082 } 12083 if value == nil { 12084 return nil 12085 } 12086 12087 shape, ok := value.([]interface{}) 12088 if !ok { 12089 return fmt.Errorf("unexpected JSON type %v", value) 12090 } 12091 12092 var cv []types.ThreatIntelligenceDetail 12093 if *v == nil { 12094 cv = []types.ThreatIntelligenceDetail{} 12095 } else { 12096 cv = *v 12097 } 12098 12099 for _, value := range shape { 12100 var col types.ThreatIntelligenceDetail 12101 destAddr := &col 12102 if err := awsRestjson1_deserializeDocumentThreatIntelligenceDetail(&destAddr, value); err != nil { 12103 return err 12104 } 12105 col = *destAddr 12106 cv = append(cv, col) 12107 12108 } 12109 *v = cv 12110 return nil 12111} 12112 12113func awsRestjson1_deserializeDocumentThreatIntelSetIds(v *[]string, value interface{}) error { 12114 if v == nil { 12115 return fmt.Errorf("unexpected nil of type %T", v) 12116 } 12117 if value == nil { 12118 return nil 12119 } 12120 12121 shape, ok := value.([]interface{}) 12122 if !ok { 12123 return fmt.Errorf("unexpected JSON type %v", value) 12124 } 12125 12126 var cv []string 12127 if *v == nil { 12128 cv = []string{} 12129 } else { 12130 cv = *v 12131 } 12132 12133 for _, value := range shape { 12134 var col string 12135 if value != nil { 12136 jtv, ok := value.(string) 12137 if !ok { 12138 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12139 } 12140 col = jtv 12141 } 12142 cv = append(cv, col) 12143 12144 } 12145 *v = cv 12146 return nil 12147} 12148 12149func awsRestjson1_deserializeDocumentThreatNames(v *[]string, value interface{}) error { 12150 if v == nil { 12151 return fmt.Errorf("unexpected nil of type %T", v) 12152 } 12153 if value == nil { 12154 return nil 12155 } 12156 12157 shape, ok := value.([]interface{}) 12158 if !ok { 12159 return fmt.Errorf("unexpected JSON type %v", value) 12160 } 12161 12162 var cv []string 12163 if *v == nil { 12164 cv = []string{} 12165 } else { 12166 cv = *v 12167 } 12168 12169 for _, value := range shape { 12170 var col string 12171 if value != nil { 12172 jtv, ok := value.(string) 12173 if !ok { 12174 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12175 } 12176 col = jtv 12177 } 12178 cv = append(cv, col) 12179 12180 } 12181 *v = cv 12182 return nil 12183} 12184 12185func awsRestjson1_deserializeDocumentTotal(v **types.Total, value interface{}) error { 12186 if v == nil { 12187 return fmt.Errorf("unexpected nil of type %T", v) 12188 } 12189 if value == nil { 12190 return nil 12191 } 12192 12193 shape, ok := value.(map[string]interface{}) 12194 if !ok { 12195 return fmt.Errorf("unexpected JSON type %v", value) 12196 } 12197 12198 var sv *types.Total 12199 if *v == nil { 12200 sv = &types.Total{} 12201 } else { 12202 sv = *v 12203 } 12204 12205 for key, value := range shape { 12206 switch key { 12207 case "amount": 12208 if value != nil { 12209 jtv, ok := value.(string) 12210 if !ok { 12211 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12212 } 12213 sv.Amount = ptr.String(jtv) 12214 } 12215 12216 case "unit": 12217 if value != nil { 12218 jtv, ok := value.(string) 12219 if !ok { 12220 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12221 } 12222 sv.Unit = ptr.String(jtv) 12223 } 12224 12225 default: 12226 _, _ = key, value 12227 12228 } 12229 } 12230 *v = sv 12231 return nil 12232} 12233 12234func awsRestjson1_deserializeDocumentUnprocessedAccount(v **types.UnprocessedAccount, value interface{}) error { 12235 if v == nil { 12236 return fmt.Errorf("unexpected nil of type %T", v) 12237 } 12238 if value == nil { 12239 return nil 12240 } 12241 12242 shape, ok := value.(map[string]interface{}) 12243 if !ok { 12244 return fmt.Errorf("unexpected JSON type %v", value) 12245 } 12246 12247 var sv *types.UnprocessedAccount 12248 if *v == nil { 12249 sv = &types.UnprocessedAccount{} 12250 } else { 12251 sv = *v 12252 } 12253 12254 for key, value := range shape { 12255 switch key { 12256 case "accountId": 12257 if value != nil { 12258 jtv, ok := value.(string) 12259 if !ok { 12260 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 12261 } 12262 sv.AccountId = ptr.String(jtv) 12263 } 12264 12265 case "result": 12266 if value != nil { 12267 jtv, ok := value.(string) 12268 if !ok { 12269 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12270 } 12271 sv.Result = ptr.String(jtv) 12272 } 12273 12274 default: 12275 _, _ = key, value 12276 12277 } 12278 } 12279 *v = sv 12280 return nil 12281} 12282 12283func awsRestjson1_deserializeDocumentUnprocessedAccounts(v *[]types.UnprocessedAccount, value interface{}) error { 12284 if v == nil { 12285 return fmt.Errorf("unexpected nil of type %T", v) 12286 } 12287 if value == nil { 12288 return nil 12289 } 12290 12291 shape, ok := value.([]interface{}) 12292 if !ok { 12293 return fmt.Errorf("unexpected JSON type %v", value) 12294 } 12295 12296 var cv []types.UnprocessedAccount 12297 if *v == nil { 12298 cv = []types.UnprocessedAccount{} 12299 } else { 12300 cv = *v 12301 } 12302 12303 for _, value := range shape { 12304 var col types.UnprocessedAccount 12305 destAddr := &col 12306 if err := awsRestjson1_deserializeDocumentUnprocessedAccount(&destAddr, value); err != nil { 12307 return err 12308 } 12309 col = *destAddr 12310 cv = append(cv, col) 12311 12312 } 12313 *v = cv 12314 return nil 12315} 12316 12317func awsRestjson1_deserializeDocumentUsageAccountResult(v **types.UsageAccountResult, value interface{}) error { 12318 if v == nil { 12319 return fmt.Errorf("unexpected nil of type %T", v) 12320 } 12321 if value == nil { 12322 return nil 12323 } 12324 12325 shape, ok := value.(map[string]interface{}) 12326 if !ok { 12327 return fmt.Errorf("unexpected JSON type %v", value) 12328 } 12329 12330 var sv *types.UsageAccountResult 12331 if *v == nil { 12332 sv = &types.UsageAccountResult{} 12333 } else { 12334 sv = *v 12335 } 12336 12337 for key, value := range shape { 12338 switch key { 12339 case "accountId": 12340 if value != nil { 12341 jtv, ok := value.(string) 12342 if !ok { 12343 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 12344 } 12345 sv.AccountId = ptr.String(jtv) 12346 } 12347 12348 case "total": 12349 if err := awsRestjson1_deserializeDocumentTotal(&sv.Total, value); err != nil { 12350 return err 12351 } 12352 12353 default: 12354 _, _ = key, value 12355 12356 } 12357 } 12358 *v = sv 12359 return nil 12360} 12361 12362func awsRestjson1_deserializeDocumentUsageAccountResultList(v *[]types.UsageAccountResult, value interface{}) error { 12363 if v == nil { 12364 return fmt.Errorf("unexpected nil of type %T", v) 12365 } 12366 if value == nil { 12367 return nil 12368 } 12369 12370 shape, ok := value.([]interface{}) 12371 if !ok { 12372 return fmt.Errorf("unexpected JSON type %v", value) 12373 } 12374 12375 var cv []types.UsageAccountResult 12376 if *v == nil { 12377 cv = []types.UsageAccountResult{} 12378 } else { 12379 cv = *v 12380 } 12381 12382 for _, value := range shape { 12383 var col types.UsageAccountResult 12384 destAddr := &col 12385 if err := awsRestjson1_deserializeDocumentUsageAccountResult(&destAddr, value); err != nil { 12386 return err 12387 } 12388 col = *destAddr 12389 cv = append(cv, col) 12390 12391 } 12392 *v = cv 12393 return nil 12394} 12395 12396func awsRestjson1_deserializeDocumentUsageDataSourceResult(v **types.UsageDataSourceResult, value interface{}) error { 12397 if v == nil { 12398 return fmt.Errorf("unexpected nil of type %T", v) 12399 } 12400 if value == nil { 12401 return nil 12402 } 12403 12404 shape, ok := value.(map[string]interface{}) 12405 if !ok { 12406 return fmt.Errorf("unexpected JSON type %v", value) 12407 } 12408 12409 var sv *types.UsageDataSourceResult 12410 if *v == nil { 12411 sv = &types.UsageDataSourceResult{} 12412 } else { 12413 sv = *v 12414 } 12415 12416 for key, value := range shape { 12417 switch key { 12418 case "dataSource": 12419 if value != nil { 12420 jtv, ok := value.(string) 12421 if !ok { 12422 return fmt.Errorf("expected DataSource to be of type string, got %T instead", value) 12423 } 12424 sv.DataSource = types.DataSource(jtv) 12425 } 12426 12427 case "total": 12428 if err := awsRestjson1_deserializeDocumentTotal(&sv.Total, value); err != nil { 12429 return err 12430 } 12431 12432 default: 12433 _, _ = key, value 12434 12435 } 12436 } 12437 *v = sv 12438 return nil 12439} 12440 12441func awsRestjson1_deserializeDocumentUsageDataSourceResultList(v *[]types.UsageDataSourceResult, value interface{}) error { 12442 if v == nil { 12443 return fmt.Errorf("unexpected nil of type %T", v) 12444 } 12445 if value == nil { 12446 return nil 12447 } 12448 12449 shape, ok := value.([]interface{}) 12450 if !ok { 12451 return fmt.Errorf("unexpected JSON type %v", value) 12452 } 12453 12454 var cv []types.UsageDataSourceResult 12455 if *v == nil { 12456 cv = []types.UsageDataSourceResult{} 12457 } else { 12458 cv = *v 12459 } 12460 12461 for _, value := range shape { 12462 var col types.UsageDataSourceResult 12463 destAddr := &col 12464 if err := awsRestjson1_deserializeDocumentUsageDataSourceResult(&destAddr, value); err != nil { 12465 return err 12466 } 12467 col = *destAddr 12468 cv = append(cv, col) 12469 12470 } 12471 *v = cv 12472 return nil 12473} 12474 12475func awsRestjson1_deserializeDocumentUsageResourceResult(v **types.UsageResourceResult, value interface{}) error { 12476 if v == nil { 12477 return fmt.Errorf("unexpected nil of type %T", v) 12478 } 12479 if value == nil { 12480 return nil 12481 } 12482 12483 shape, ok := value.(map[string]interface{}) 12484 if !ok { 12485 return fmt.Errorf("unexpected JSON type %v", value) 12486 } 12487 12488 var sv *types.UsageResourceResult 12489 if *v == nil { 12490 sv = &types.UsageResourceResult{} 12491 } else { 12492 sv = *v 12493 } 12494 12495 for key, value := range shape { 12496 switch key { 12497 case "resource": 12498 if value != nil { 12499 jtv, ok := value.(string) 12500 if !ok { 12501 return fmt.Errorf("expected String to be of type string, got %T instead", value) 12502 } 12503 sv.Resource = ptr.String(jtv) 12504 } 12505 12506 case "total": 12507 if err := awsRestjson1_deserializeDocumentTotal(&sv.Total, value); err != nil { 12508 return err 12509 } 12510 12511 default: 12512 _, _ = key, value 12513 12514 } 12515 } 12516 *v = sv 12517 return nil 12518} 12519 12520func awsRestjson1_deserializeDocumentUsageResourceResultList(v *[]types.UsageResourceResult, value interface{}) error { 12521 if v == nil { 12522 return fmt.Errorf("unexpected nil of type %T", v) 12523 } 12524 if value == nil { 12525 return nil 12526 } 12527 12528 shape, ok := value.([]interface{}) 12529 if !ok { 12530 return fmt.Errorf("unexpected JSON type %v", value) 12531 } 12532 12533 var cv []types.UsageResourceResult 12534 if *v == nil { 12535 cv = []types.UsageResourceResult{} 12536 } else { 12537 cv = *v 12538 } 12539 12540 for _, value := range shape { 12541 var col types.UsageResourceResult 12542 destAddr := &col 12543 if err := awsRestjson1_deserializeDocumentUsageResourceResult(&destAddr, value); err != nil { 12544 return err 12545 } 12546 col = *destAddr 12547 cv = append(cv, col) 12548 12549 } 12550 *v = cv 12551 return nil 12552} 12553 12554func awsRestjson1_deserializeDocumentUsageStatistics(v **types.UsageStatistics, value interface{}) error { 12555 if v == nil { 12556 return fmt.Errorf("unexpected nil of type %T", v) 12557 } 12558 if value == nil { 12559 return nil 12560 } 12561 12562 shape, ok := value.(map[string]interface{}) 12563 if !ok { 12564 return fmt.Errorf("unexpected JSON type %v", value) 12565 } 12566 12567 var sv *types.UsageStatistics 12568 if *v == nil { 12569 sv = &types.UsageStatistics{} 12570 } else { 12571 sv = *v 12572 } 12573 12574 for key, value := range shape { 12575 switch key { 12576 case "sumByAccount": 12577 if err := awsRestjson1_deserializeDocumentUsageAccountResultList(&sv.SumByAccount, value); err != nil { 12578 return err 12579 } 12580 12581 case "sumByDataSource": 12582 if err := awsRestjson1_deserializeDocumentUsageDataSourceResultList(&sv.SumByDataSource, value); err != nil { 12583 return err 12584 } 12585 12586 case "sumByResource": 12587 if err := awsRestjson1_deserializeDocumentUsageResourceResultList(&sv.SumByResource, value); err != nil { 12588 return err 12589 } 12590 12591 case "topResources": 12592 if err := awsRestjson1_deserializeDocumentUsageResourceResultList(&sv.TopResources, value); err != nil { 12593 return err 12594 } 12595 12596 default: 12597 _, _ = key, value 12598 12599 } 12600 } 12601 *v = sv 12602 return nil 12603} 12604