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